In recent months, the exponential improvement of Chinese AI models combined with rising costs from American AI providers has pushed a lot of people to try out the cheap Chinese models. However, if you’re not careful, cheap can end up costing you more.

Something we should keep in mind when choosing an AI model, besides its price, naturally, is its capability. However, it seems to me that benchmarks most of the time don’t reflect reality. I’m one of those who believe there are AI providers training their models specifically to score better on benchmarks than the competition while neglecting the model’s overall performance. I don’t want to give any specific example, since within a week it would be outdated. Still, the hype about Chinese models always moves the same way:

1. A new Chinese model comes out, scores very well on benchmarks, and is cheaper than its American counterparts
2. Lots of people on X and other forums announce the death of American AI models (Claude and OpenAI) in terms of quality/price
3. After the excitement comes the disappointment when these models are actually tested
4. Lots of people on X and other forums announce that American AI models aren’t so dead after all

Why does the disappointment come? Users who try to code with Chinese models realize that to complete a task they need several iterations fixing errors before reaching an acceptable final result. American models, however, manage to reach the final result in far fewer iterations. Every iteration costs time and tokens. So, to reach the same final result, the Chinese model took 6 iterations that cost X, while the American model took 2 iterations that also cost X. The difference is that with the 6 iterations we spent an hour and a half, and with the 2 iterations we spent half an hour. Conclusion: cheap ends up expensive.

I don’t want to be misunderstood. Chinese models are very useful for some things, like work that’s very well specified beforehand, write documentation, or routine tasks, and I’m leaving out of this analysis advantages like open weights or data control, which for some use cases matter more than the cost per iteration.

I also think we often make the mistake of equating specific Chinese models with specific American models. For example: DeepSeek’s flash models are very powerful, very fast, and very cheap relative to what we can do with them, but we can’t expect to use them as a substitute for Sonnet. If we use it as a substitute for Haiku, we find a model that’s faster, cheaper, and, in my view, more capable.

If we want to use Chinese flagships, we need to be very careful at the design stage so we don’t run into a lot of errors at the implementation stage. I feel that American models give me a bit more peace of mind on this front. Nor do I think it’s a great idea to always use mid-tier American models, like Sonnet or Terra, or to always use high-tier American models while blindly trusting their output. If we want to save money while keeping quality, it’s sometimes better to use a higher-tier model at a lower effort level than a lower-tier model at a higher effort level. Every model is designed for a specific level of task. It’s not good to use a sledgehammer to crack a nut, but we won’t get good results either if we try to bring down a sledgehammer’s job with a slingshot. It’s important to keep in mind that finding an error after the implementation stage forces us to do a full iteration, consuming more tokens when the context is already loaded, whether to compact it or to continue the session. We should do everything possible to avoid finding errors so late, and, apart from many other techniques beyond the scope of this article (guardrails, linters, tests, and skills), choosing the right model and effort level helps us in this mission without losing sight of the cost.