Lately I have been feeling more and more strongly that one of the most overrated things in AI is the release of a new model itself.

Not long ago, every new version triggered the same reaction: how much smarter is it, how much stronger is it, how high will it climb on the charts. That reflex is starting to wear out. It is not that models no longer matter. It is that users, especially developers, have become much more practical. Fine, you shipped an upgrade. But the real question now is: so what?

The Hacker News discussion comparing Opus 4.6 and 4.7 was a good example. It drew 517 points and 509 comments, which is not small. But the most interesting part was not the heat. It was the shift in what people actually cared about. The conversation was not dominated by launch rhetoric. People were picking apart the economics: token usage, reliability, failure modes on long tasks, and whether the new version saved real time once it entered an actual workflow.

Put simply, AI has started moving from a phase of chasing novelty into a phase of doing the math.

Why people are no longer automatically impressed by new models

The reason is not complicated. A lot of people have already been burned by the upgrade treadmill.

Over the past year, release cadence has been absurdly fast. First 4.5, then 4.6, then 4.7. The naming sounds incremental, but the marketing often sounds revolutionary. So people do what the industry trained them to do: try the new thing, rewrite prompts, retune parameters, switch integrations, and re-adapt the toolchain. Then, after all that work, the result is often not a huge productivity jump. It is just another day spent migrating for gains that feel smaller than promised.

Developers feel this most sharply.

A regular user might be happy if the model just feels a little smarter. Developers do not evaluate it that way. They ask a very different set of questions:

  • Does token usage increase materially on the same task?
  • Is output quality more consistently better, or just occasionally impressive?
  • Is latency still acceptable?
  • Does long-context performance remain stable?
  • Are tool calls more reliable?
  • When things go wrong, is the human fallback cost lower or higher?

None of these questions are glamorous. All of them matter.

Because developers are not casually testing a demo. They are trying to insert a model into real work. The moment that happens, the standard changes from “is it smart?” to “is it worth it?”

What matters is not the ceiling of capability, but the total return

I have never been very fond of stories built entirely on benchmark charts. It is not that benchmarks are useless. It is that they create a very easy illusion: if the score is higher, then the value must also be higher.

Reality is not that neat.

If you want to judge whether a model is worth adopting, you usually need to look at at least four different ledgers.

1. The cost ledger

This is the most obvious one.

If a new model is eight points better in capability but forty percent more expensive, many teams will not react with excitement. They will react with hesitation. In workloads with frequent calls, long context windows, and repeated refinement, token costs get ugly fast.

It is easy to say people should happily pay for stronger capability. It is harder to say that when the monthly bill shows up.

That is why many teams now take a very simple view: a model can be more expensive, but it has to earn that price. It has to reduce rework, reduce review time, reduce debugging, reduce reruns. Otherwise the so-called upgrade may just be a faster way to burn budget.

2. The reliability ledger

This one is still underrated.

A model that is occasionally brilliant is not necessarily the most useful. What matters is whether the thirtieth call and the hundredth call still hold together.

What developers fear is not a model that is a little less smart. They fear a model that suddenly becomes less stable. Tool calls work one day and break formatting the next. Structured output behaves today and improvises tomorrow. Long tasks stay coherent until, halfway through, context quietly falls apart.

That kind of assistant is exhausting. It feels like working with a talented colleague whose performance depends on the weather.

That is why so many serious discussions now revolve less around “is it stronger?” and more around “is it steadier?” It may sound less exciting, but it is a much more mature question.

3. The workflow ledger

This is the most important one, and also the easiest one for marketing to dodge.

A model can be very strong in isolation and still lose most of its value once it enters a real workflow.

Take coding as an example. What developers often care about is not whether one answer looks beautiful in a screenshot. They care whether the model can:

  • keep track of repository context over time
  • call tools reliably
  • avoid unnecessary detours
  • reduce manual patching
  • remain consistent across long task chains

If a new model only makes demos look better, but still stumbles inside IDEs, agents, automation loops, and test pipelines, it is hard to make it the default workhorse.

That is why more people are now asking not “which model is the strongest?” but “which model creates the least friction inside my workflow?”

That question is far more honest than a ranking table.

4. The migration ledger

A lot of writing ignores this because it ruins the drama.

But the reality is that every model switch has a cost.

Prompts need to change. System instructions need to change. Fallback logic needs to change. Rate-limit assumptions need to change. Evaluation suites need to be rerun. Even the habits of the team often need to be rebuilt. Very little of that shows up on a launch slide, but it is still real money and very real attention.

So whether a model is worth it cannot be answered only by asking how much stronger it is in theory. You also have to ask how much rework it demands in return.

If the upside is modest while the migration burden is nontrivial, then sticking with an older version is not conservative at all. In many cases, it is the more professional decision.

This is a sign that the AI market is maturing

I actually think this is healthy.

In the earliest phase of an industry, people fall in love with whatever is new. As the market matures, the questions become simpler and more grounded:

  • Can this thing do stable work?
  • Does this thing justify what it costs?

AI has clearly entered that stage.

Model companies used to talk mostly about records: what they beat, what they topped, what they advanced. Now users want something else:

  • What tasks improved?
  • By how much?
  • At what cost?
  • What does that mean for an existing workflow?
  • Is it genuinely worth switching?

That shift matters. It means people are no longer just watching for miracles. They are evaluating tools.

And once buyers start thinking like buyers, the criteria change completely. Buyers do not pay for fireworks. They pay for return.

What model companies should compete on next

Honestly, continuing to compete on launch hype is getting dull.

The next meaningful competition should be around a different set of things.

First, make pricing legible

Stop hiding behind vague positioning. Expensive is expensive. Cheap is cheap. Users are not afraid of paying more. They are afraid of paying more without understanding why.

Second, be specific about where the upgrade helps

Not every new version needs to be framed as universally better at everything. People are getting tired of that language.

A much more credible message would be: these tasks improved a lot, these changed only a little, these are still unstable. The more honest the framing, the more trust it earns.

Third, treat reliability as a headline feature

I honestly think one of the most persuasive product messages for developers in the next phase will not be “more powerful.” It will be “more reliable.”

More reliable structured output. More reliable tool use. More reliable long-task behavior. More reliable cost expectations. None of that sounds flashy. All of it is valuable.

Fourth, show workflow gains that can actually be verified

One-turn screenshots are losing persuasive power fast.

If companies really want people to believe that a new model is worth the switch, they need to show complete chains: how long a task used to take, how much time the new model saved, how much manual review it removed, how much failure rate dropped. That is the kind of evidence that deserves to be called value.

One honest closing thought

I am not saying new models no longer matter. They do. Without model progress, a lot of product experiences would simply never improve.

But I am much less willing now to accept the old narrative that every fresh release deserves applause by default.

Developers today are not short on announcements. What they are short on is certainty. They want a model that actually saves money, saves time, and saves mental overhead once it enters real work, not one that merely wins attention for a night on social media.

So when I look at threads like the Opus 4.6 versus 4.7 debate, my reaction is not that people have become cynical. If anything, I think they have become more mature.

They are finally asking the question they probably should have asked first all along:

is it actually worth it?

Once that becomes the main question, the shape of AI competition changes with it.

The winners may not be the companies that release the most new versions.

They may be the ones that can explain, clearly and credibly, the full balance between capability, cost, reliability, and workflow return.

That is not flashy. It is just real. And in the end, the people who actually spend money tend to care about real things.