LLMs reward expertise

Everyone assumes that large language models flatten the playing field. Type a question, get an answer, and suddenly the person who never learned CSS is writing sort-of-okay stylesheets right alongside the person who's done it for a decade. That leveling effect is real, and it's why a lot of people have concluded there's no actual skill in prompting anymore — since everyone's talking to the same models, the thinking goes, skilled prompters and total newcomers should land in roughly the same place.

That conclusion doesn't hold up. Terence Tao's exchange with ChatGPT about a newly-discovered counterexample to the Jacobian Conjecture makes the case better than any abstract argument could. The model in that conversation barely resembles the one most people interact with. Tao's messages are clipped and to the point, he responds to the gist rather than litigating every line, and the model answers him with a concision that just doesn't show up when an amateur asks the same system about math. Signal your expertise, and the model apparently shifts into a different register — talking mathematician to mathematician instead of explaining things to a beginner.

What's striking is how little of this comes down to technique you could copy wholesale. Tao pushes back on the model without flatly contradicting it, saying things like a response looks more complex than he was hoping for. He proposes his own leaps rather than following where the model suggests. But none of that works unless you actually understand the math well enough to pull the right thread out of a dense paragraph and notice when something looks off. You can't fake that part.

The same pattern shows up in something as ordinary as working inside a codebase. Someone with a real mental model of their system can push back — no, this could be simpler, don't we already handle that elsewhere, can we frame this in terms we already use — in ways that someone unfamiliar with the code simply cannot. That tracks with a broader idea that system design problems tend to hinge on concrete specifics rather than sweeping general principles. Deep familiarity with one particular codebase beats a general theory of software architecture almost every time, because it's the specifics that let you ask the sharp, narrow questions — does this work here, given this and that, why does it do this — that actually move a conversation with an LLM forward.

None of this means people without domain knowledge get nothing out of these tools — they clearly get something, and that's not nothing. But the gap between that and what an expert can extract from the identical model is enormous, because the expert can steer hard toward exactly what they want. The knowledge is sitting inside the model already; the hard part, increasingly, is having a human on the other end who knows precisely how to drag it out. That's a case for human expertise mattering more, not less, as these systems get more capable — the bottleneck moves from the model's knowledge to the user's ability to specify exactly what they're after.