Your Best Prompt Is a Decade of Expertise

On July 21, Terence Tao did something quietly useful: he published a raw ChatGPT transcript. No editing, no victory lap — just a working mathematician digesting the freshly announced counterexample to the Jacobian Conjecture, an algebra problem that had stood open since 1939. Three days later, GitHub engineer Sean Goedecke read that transcript and wrote down the sentence a lot of the industry has been dancing around: "The most important skill in prompting is expertise in the domain you're prompting for." The post pulled 1,200-plus points on Hacker News, and the 500-comment thread split exactly along the fault line you'd predict.

The backstory matters here. The counterexample wasn't Tao's, and it wasn't ChatGPT's. Levent Alpöge, a mathematician at Anthropic, found it days earlier working with Claude Fable 5: a three-variable polynomial map whose Jacobian determinant is a constant −2 but which sends three distinct inputs to the same output. The construction is short enough to fit in a social media post, which is why mathematicians around the world verified it within hours (the two-variable case remains open, and the result hasn't been through formal peer review). Tao's session came after the announcement. He handed the model an alternate construction and steered it, exchange by exchange, through checking whether that route could retroactively explain where the counterexample came from.

Goedecke's reaction to reading it: "This is not the same ChatGPT I talk to! I couldn't get to where Tao gets, even with unlimited tokens to burn." Same product, same weights, unrecognizable output. That gap is the whole story.

Prompt engineering didn't survive contact with reasoning models

Remember when prompting was a bag of tricks? "Let's think step by step," assigning the model a persona, promising it a tip. Those incantations worked because 2022-era models were undertrained at following instructions, and they died because later training runs internalized them. Reasoning models plan and self-check without being begged to. The trick layer got absorbed into the product, which is why "prompt engineer" quietly vanished as a job title.

What Tao does in his transcript is not technique in that sense, and you can verify this yourself — the session is public. His messages are short and targeted. He makes the model verify each algebraic identity before building on it. When an approach balloons, he pushes back — "this looks more complex than I was hoping for" — instead of politely following the model into the weeds. He proposes his own directions rather than choosing from the menu the model offers. None of that is syntax. All of it is judgment, and judgment is the part you can't copy from a prompting guide, because it comes from knowing what a good answer looks like before you've seen one.

The leveler and the multiplier are both real

The popular narrative says AI flattens skill curves, and there's honest evidence for it. The widely cited 2023 BCG field experiment found that generative AI lifted bottom-half consultants roughly twice as much as top performers. Goedecke concedes the same point for code: "Today, everyone can write sort-of-okay CSS by delegating the task to an LLM. LLMs make everybody into a generalist."

But the Tao transcript is evidence for the opposite effect at the other end of the distribution. The model raised the floor for everyone; it raised the ceiling only for people who can steer. Both things are true because they're happening to different parts of the curve — the distribution isn't compressing, it's stretching. The squeeze lands in the middle: shallow generalist knowledge, the kind that used to be a decent career (knowing a framework's API surface, writing serviceable glue code), is now table stakes that anyone can rent for $20 a month. Deep knowledge of a domain, a codebase, a problem's structure just went up in price, because it's the input the model can't supply for itself.

What this looks like at the keyboard

Translate Tao's moves into agentic coding and they're immediately recognizable. Short, specific asks beat essay-length context dumps. Verify at checkpoints — make the agent run the tests after each change, the way Tao made ChatGPT confirm two maps were mutually inverse before composing them. Kill a bad direction in message two, not message twelve, because agents compound their own errors. And come in with your own theory: the developer who can say "the invalidation belongs in the write path — the cache layer shouldn't own consistency" gets a usable diff on the first try, while the one who can only say "still broken, fix it" gets an afternoon of thrash. Goedecke's version: "If you have a good theory of your codebase, you can push the LLM much harder than if you have no familiarity."

One honest caveat: expertise alone doesn't guarantee a payoff. METR's 2025 randomized trial found experienced open-source maintainers were 19% slower with early-2025 AI tools while believing they were 20% faster (METR itself expects current tools do better). The experts who lost time were the ones who trusted output they should have checked. Domain knowledge pays out through skepticism — knowing when the model is wrong — not through fancier requests. It's the verification half of Tao's loop, and it's the half most people skip.

The strongest pushback in the HN thread deserves a straight answer: plenty of non-experts ship real software now. Someone's girlfriend built a working Telegram bot on free-tier Gemini; an HR manager deployed an app with Lovable in an afternoon. True, and not actually a counterexample. Those platforms work by embedding the expertise — scaffolding, deploy pipelines, guardrails — so the user doesn't need it. That's expertise rewarded at one remove, packaged by the vendor. The bill arrives when you step off the paved road: the first weird auth bug, the first migration, the first feature the template didn't anticipate.

Bet on depth

There's one more asymmetry worth naming. The Jacobian counterexample went viral partly because verifying it was trivial — a few lines of algebra anyone could check by hand. Most work isn't like that. In software, verification is usually the expensive half of the job, and that's precisely the half expertise buys. As models get stronger, Goedecke argues, "the human is the bottleneck, not the model" — and the bottleneck skill is specifying and checking, not generating.

So the career advice writes itself, even if it's unfashionable. "Learn prompting" was always a depreciating asset. The durable version is: learn a domain deeply enough to have opinions the model has to argue with. For junior developers, that means treating the model as tuition — interrogate its output until you understand it — rather than renting a theory of the codebase you never build. The people getting the most out of these tools were expensive to make, and the models, so far, are making them more valuable rather than less.