GitHub Copilot changed pricing, so I rebuilt my entire AI coding stack with Chinese models

And honestly? I don’t think I’m going back.

For the past year, my development workflow looked pretty similar to everyone else’s.

• VSCode.
• GitHub Copilot.
• Claude Sonnet.
• GPT-5.
• A few prompts.
• A few tabs open.
• Ship code.

I was on GitHub Copilot Pro + with the 1500 premium requests plan, and like many backend developers, I slowly became completely dependent on it without even realizing it.

At some point, AI stopped being a “helper” and quietly became part of my actual engineering process.

And then something happened that I think is going to push a massive shift across the industry over the next 12 months:

AI coding stopped being about the best model; it became about cost, orchestration, workflows, and token economics. And once Copilot changed pricing and usage limits, I finally started looking under the hood.

That’s when I discovered something I honestly wasn’t expecting:

Chinese AI models are quietly becoming good enough to replace frontier models for most real-world coding tasks. But not just in benchmarks, in actual production workflows. And that completely changed my stack.

The Copilot Illusion

The biggest thing I realized is that Copilot was hiding the real economics of AI coding.

When you use:

• Claude Sonnet,
• GPT-5,
• or Gemini,

Inside a polished subscription product, you don’t really feel the token consumption.

But once you move into:

• OpenCode,
• OpenRouter,
• agent workflows,
• sub-agents,
• memory systems,
• autonomous loops,

You suddenly see the real numbers, and they are brutal, especially if you code professionally every day.

My team and I work on backend development. Nothing insanely academic, nor compiler engineering, nor AGI research. And that’s important because most AI benchmarks are completely disconnected from the reality of production development.

I don’t care if a model solves a PhD-level graph theory problem. I care if it can:

• understand a repository,
• make a minimal change,
• not break DI,
• preserve patterns,
• respect architecture,
• and avoid hallucinating abstractions I never asked for.

That’s the real benchmark.

The Frontier Model Problem

Let me say something slightly controversial: Claude Sonnet is still the best coding model overall. I genuinely believe that, and the difference is real.

But there is also another reality: Claude is expensive enough that it changes how you work. Once you start using agent frameworks, the token consumption explodes. And I mean EXPLODES.

One simple task (especially if you use SDD) is suddenly not one request anymore. It’s 8 requests, 14 internal reasoning phases, 200K+ tokens, and multiple tool calls. And at scale, that matters A LOT.

So I started asking myself. Instead of: What’s the smartest model?, What’s the smartest model I can sustainably use all day?

Then I Tried the Chinese Models

At first, I expected them to be overhyped. Especially after all the Twitter benchmark wars.

But then I tested them in actual workflows. And honestly?

Some of them are shockingly good. Not “good for open-source”. Not “good for the price”. Actually good.

Qwen Changed My Mind First

The first model that really surprised me was Qwen. Especially Qwen3-Coder. Alibaba quietly built something extremely serious. And what makes Qwen interesting isn’t just raw intelligence.

It’s that the model feels optimized for:

• tooling,
• repositories,
• CLI workflows,
• coding agents,
• structured engineering tasks.

Which matters a lot once you move into systems like:

• OpenCode,
• autonomous workflows,
• multi-agent execution.

For backend development, it’s honestly excellent. And most importantly:

It’s cheap enough that you stop worrying about using it.

That changes your behavior dramatically. You stop “saving requests”.

You experiment more. You iterate more. You delegate more tasks to agents.

And suddenly, the workflow itself becomes better.

Kimi K2 Was Even More Surprising

Kimi feels different. Less structured than Qwen, less “engineering-focused”. But absurdly good at generation.

Especially:

• scaffolding,
• frontend,
• rapid prototyping,
• long outputs,
• implementation speed.

I understand immediately why it exploded in the developer community. The value proposition is insane.

The problem is that you can also feel its weaknesses faster.

• Long-running workflows degrade more.
• Context retention is weaker.
• Agentic consistency drops faster.

But for the price? It’s kind of ridiculous. And I think this is the part the industry still hasn’t fully absorbed:

The gap between frontier models and Chinese models is shrinking faster than the price gap.

OpenCode Changed Everything

This was probably the biggest shift for me. Moving away from “AI inside the IDE” into:

• OpenCode,
• terminal agents,
• orchestration,
• model routing,
• external memory,
• sub-agents.

Once you experience that workflow, it becomes very hard to go back. Because you realize something important:

The future of AI coding is probably not a chatbot. It’s an operating system.

And that’s where OpenCode becomes incredibly interesting. Because it turns models into infrastructure.

You can:

• route models,
• combine them,
• optimize costs,
• assign specialized tasks,
• separate cheap reasoning from expensive reasoning.

Suddenly:

• Claude becomes your architect,
• Qwen becomes your daily engineer,
• DeepSeek becomes your utility worker,
• Kimi becomes your rapid generator.

And the orchestration layer becomes more important than the model itself. That’s a huge paradigm shift.

The Agent Era Is Already Here

I think most people still underestimate how fast this transition is happening. We’re moving from:

“Ask AI a question.”

to:

“Assign AI a workflow.”

That’s completely different. And honestly, we are seeing the shape of what software engineering might look like in 2–3 years.

A single senior engineer suddenly operating with:

• multiple reasoning systems,
• delegated execution,
• persistent memory,
• automated exploration,
• autonomous tooling.

That’s where this is heading.

And interestingly enough, the winners may not be the companies with the absolute smartest models.

They may be the companies with:

• the best orchestration,
• the best workflows,
• the best economics,
• the best developer UX.

That’s why I think Chinese models matter so much.

Because they’re forcing the industry to confront something uncomfortable:

Frontier intelligence alone is no longer enough.

My Current Stack

Right now, my setup looks roughly like this:

IDE

VSCode

Coding Layer

OpenCode

Memory + Agents

Gentle AI

Routing

OpenRouter

Models

• Qwen3-Coder → primary daily driver
• Claude Sonnet → architecture/debugging
• DeepSeek → utility tasks
• Kimi K2 → rapid generation

This setup feels more powerful than Copilot ever did. Not because the models are smarter.

Because the workflow is smarter.

Final Thought

I think we’re entering the phase where AI coding becomes less about “Which model is best?” and more about “Which system lets developers think faster?”

That’s a much bigger shift. And I genuinely believe that in a year, most senior developers won’t rely on a single AI provider anymore.

They’ll run:

• multi-model workflows,
• agent systems,
• external memory,
• routing layers,
• specialized coding stacks.

Exactly like we already do with cloud infrastructure.

And when that happens, the market changes completely.

Because the most important thing stops being intelligence.

It becomes leverage.