AI capability is not a single number climbing toward a line marked "human." It is a jagged frontier — superhuman at some tasks, worse than a seven-year-old at others, with no smooth relationship between the two — and the same model that drafts a competent legal brief will, in the next exchange, insist that "strawberry" contains two r's. The jaggedness, not the average level, is what makes AI hard to deploy, and it is why "AGI" is a category error rather than a milestone you cross.
The phrase "jagged frontier" comes from a 2023 field experiment run with management consultants at BCG by a Harvard Business School-led team including Fabrizio Dell'Acqua, Karim Lakhani, and Ethan Mollick. Consultants using GPT-4 did dramatically better on tasks that fell inside the model's competence — faster, higher quality, more of them. On a task deliberately chosen to sit just outside that competence, the AI users did worse than the control group, because the model produced fluent, confident, wrong analysis and the humans deferred to it. Same model, same users, opposite outcome. The boundary between the two conditions was marked on no map.
The map from human-hard to model-hard is scrambled
Start with the observation that should reorganize your intuition: the tasks humans find hard and the tasks models find hard are drawn from two different, largely unrelated distributions.
A frontier model can recall and synthesize more text than any human who has ever lived, generate fluent prose in a dozen registers, translate between languages, and write working code in seconds — all things humans find genuinely difficult and spend years training for. The same model can fail at counting the letters in a word, tracking which block sits on top of which in a three-block stack, doing multi-digit arithmetic reliably without a tool, or — most consequentially — knowing when it doesn't know. These are things a child does without effort.
We keep being surprised because we import a human prior about difficulty. For a person, the ability to write a coherent legal argument strongly predicts the ability to count to five; both sit on a single latent axis we call "smart," and that axis is why one number ("she's brilliant") is a useful compression of a human's abilities. The whole "AI is at the level of a college graduate / a PhD / a median coder" genre assumes that same scalar exists for models. It does not. The correlation between "can write the brief" and "can count the letters" — near-total in humans — is close to zero in a language model, because the two capabilities come from entirely different features of how it was built.
The frontier is jagged because capability tracks the training distribution, not human intuition
The mechanism is not mysterious. A model's competence at a task tracks two things: how densely that task's structure is represented in the training distribution, and how well the task's actual computation matches the operations the architecture performs cheaply. Neither has any reason to line up with what humans find easy or hard.
Take the letter-counting failure, because it is the cleanest illustration. A language model never sees individual characters the way you do. Text is chopped into tokens — subword chunks — before the model sees anything, so "strawberry" might arrive as two or three opaque units, and the letters inside them are simply not present as discrete objects the model can iterate over. Asking it to count the r's is like asking you to count the brushstrokes in a word you can only hear spoken. The task is trivial for a human representation of the input and structurally awkward for the model's representation. Nothing about the model being "smarter" fixes this, because the difficulty lives in the mismatch between task and substrate, not in some general competence dial.
Now generalize. Fluent prose is easy for the model because the training distribution is made of fluent prose — predicting the next token is the same objective as generating it, and there is more prose than of anything else. Robust arithmetic is hard because getting a 12-digit multiplication right requires an exact, carry-propagating algorithm, and the model learned a soft statistical approximation of "what a product looks like" — right often enough to be dangerous and wrong often enough to be useless. Physical common sense — that a poured liquid falls, that you can't push a rope — is thin in text because humans rarely bother to write down what everyone already knows, so the model's grip on it is patchy in exactly the places our intuition expects it to be solid.
This is the concrete, task-level face of a deeper point I've argued separately: a language model captures the correlational structure of its training data with extraordinary fidelity, but prediction is not understanding, and the ceiling that gap creates does not fall along the contours of human difficulty. The jags are precisely where correlation-in-text and truth-in-the-world come apart.
We also cannot read the frontier off the model's internals, because we don't yet know how to read the internals at all. The features a model uses are smeared across neurons in overlapping, entangled ways — the superposition problem means a single neuron participates in many unrelated concepts and a single concept is spread across many neurons. There is no dashboard where "arithmetic: unreliable" lights up. Competence and incompetence are woven into the same weights, invisible until a specific input pulls one or the other out.
The single clearest correction to "AI is at X level"
Here is the reframing worth keeping. When someone says "this model is at the level of a competent analyst," the sentence is not merely imprecise — it is type-wrong. It projects a jagged, high-dimensional capability surface onto a one-dimensional ladder, and every important decision you make about the model inherits its error from that projection.
The average is real but nearly useless — the way "average depth" is useless for deciding whether to wade across a river. A river averaging three feet deep will drown you in the channel you didn't see. The question is never "how deep on average" but "how deep on the path I'm about to take." A model's average benchmark score is the average depth. Your specific task is your specific path.
This also dissolves a chunk of the AGI debate. Much of the takeoff-speed argument — fast/hard versus slow/soft — and much of the "when do we hit human-level" forecasting quietly assumes the scalar exists, so that we can meaningfully ask when the number crosses the line. On a jagged frontier there is no single line to cross. The model is already superhuman at recall and subhuman at knowing the limits of its own knowledge, and it can get more superhuman at the first without the second budging. Even Bostrom's orthogonality thesis — that a system's intelligence and its final goals vary independently — treats competence as one axis. The honest picture has competence itself fanning out into many.
The danger zone is just past the edge of competence
The deployment consequence follows directly, and it is sharper than "sometimes the model is wrong."
A model that is obviously incompetent at a task is safe. It fails visibly, you don't rely on it, no harm done. A model that is genuinely competent is also safe — you rely on it and it delivers. The danger is the thin band where the model is operating just past the edge of its competence while still producing output that looks exactly like its competent output: same confident tone, same fluent structure, same absence of hedging, attached to a wrong answer. That is precisely the condition the BCG consultants walked into. The failure was invisible because the model's calibration doesn't degrade gracefully at the edge. It doesn't get visibly unsure as it leaves its depth. It stays fluent right off the cliff.
Poor calibration — the model not knowing what it doesn't know — is itself one of the jags, and it is the worst-placed one, because it removes the signal you'd use to detect all the others. A human expert leaving their expertise usually feels it and says "I'm not sure." The model has no reliable version of that feeling to report.
Because the frontier is jagged and invisible, you cannot locate the edge by reasoning about it from outside. Two tasks that look nearly identical to you — "summarize this contract" and "summarize this contract and flag the unusual clauses" — can sit on opposite sides of the frontier, because the second requires a comparison against a distribution of normal contracts that the model may or may not represent well. Surface similarity, the thing your intuition uses to predict competence transfer, is exactly the unreliable signal here.
What to actually do: map your frontier empirically
Stop treating capability as a property you can infer and start treating it as a measurement you have to take.
Map the jagged frontier for your use case, on your tasks. Not the benchmark's tasks, not the demo's tasks, not the neighboring task that looks similar. Build an evaluation set from the actual inputs your system will see, including the ugly edge cases, and measure where competence holds and where it breaks. Then design the workflow around the shape you found: trust the model's direct output only inside the verified region, keep a human or a tool at the boundary, and route the known-hard structural tasks — exact arithmetic, counting, retrieval of ground truth — to a calculator, a database, or code, rather than to the model's soft approximation. Evaluation on your own tasks is not diligence theater; it is the only way to see a frontier that is invisible by construction.
Jaggedness is also where the leverage lives. Kasparov's response to losing to Deep Blue was "advanced chess" — human-plus-machine teams, later called centaurs, that for a while beat both unaided humans and unaided engines by pairing complementary strengths. The reason a centaur can win is that the two players are jagged in different places; the human covers the machine's holes and the machine covers the human's. David Autor's task-based account of automation is the same insight in the labor market: technology doesn't replace jobs, it replaces tasks, unevenly — hollowing out some parts of a role while leaving others untouched and sometimes raising their value. Both only make sense once you stop thinking in single numbers and start thinking in task-level surfaces.
So the correction is not "AI is overhyped," and it is not "AI is underrated." Both are still trying to move one dial. There is no dial. There is a landscape — superhuman peaks beside subhuman crevasses, the crevasses unmarked, the model striding across all of it with identical confidence. Your job is not to ask how high the average is. It is to find the crevasses before your users do.