A new AI scored 70% on hard tests instead of 50%. Impressive. Still failing a third of everything. The multiplication that explains why, the paradox that better models create more work instead of less, and what it means for someone studying to enter this industry right now.
When GPT-6 Astra came out, my feed split in two within hours. Half said programmers are finished. The other half said programming is finished: solved, done, the AI does it all. Both camps were reacting to a test score as if it were a prophecy.
I'm a student, so this isn't abstract for me. It's my career being debated by strangers. Here's the small, boring truth I keep coming back to: a test score is not a coworker. Someone who gets 70% on an exam still gets nearly a third of everything wrong. You wouldn't hand them anything important. Why would you hand them production systems?
The only math you need
Real AI work isn't one question. It's chains of steps. Research, write, run, check, fix, repeat. At 85% reliability per step (generous!), ten steps succeed under 20% of the time. At 70% per step, under 3%. Going from 50% to 70% on benchmarks is genuinely hard engineering worthy of respect. But a component failing a third of the time is something you build guardrails around. Not something you hand the wheel to.
The paradox: better models, more work
Here's the second-order effect the panickers and the-partiers both miss. When models get more capable, teams don't relax. They expand what they attempt. Tasks that were unthinkable at 50% become tempting at 70%: longer autonomous runs, bigger refactors, less supervision. But each newly-attempted workflow inherits the same compounding math, so total failures can rise even as per-step reliability improves. Economists know this shape well: efficiency gains in a resource increase its consumption. Better models don't mean less verification work. They mean verification work on grander ambitions.
That reframes the career question I actually get asked by fellow students: should I still be learning this? Yes. But learn the part that compounds in value. The better models get, the more the bottleneck shifts from writing code to judging it: specifying precisely, reviewing ruthlessly, owning consequences. The engineers who thrive won't be the fastest typists (that game is over) but the ones whose judgment you trust at 2am when the AI-generated migration looks right and isn't. Taste, specification, accountability. The un-automatable residue. Study that.
What I actually do with a new model
Demos are filmed in perfect conditions: clean data, one tidy project, invisible retries. My work is the opposite: old code, weird databases, deadlines. So I ignore leaderboards and run candidates on my stuff: a real refactor from my own repos, a strict-format task, a job where the first attempt fails and recovery matters. My full ritual for that lives in how I compare models on my own repos. If it doesn't win there, the announcement means nothing to me.
Three rules that survive every release cycle:
- Price the whole picture. Slightly smarter at 3x latency and 4x token cost made your pipeline worse, not better.
- Keep the guardrails. Strict checks, automated tests, limited permissions. The dumber the safety net, the better, because it can't be talked out of anything.
- Mute the timeline. Launch-day takes are entertainment. Your own measurements are information.
- 70% is a milestone for researchers, not a promotion to production. Multiply across your workflow first.
- Capability gains expand attempted work faster than they reduce failures. Verification demand grows, not shrinks.
- Students: study judgment, specification, and accountability. That's the residue automation can't absorb.