The AI Coding Landscape: Model Tiers, Tool Camps, and a Deep Dive into MCP/Skills/CLI

From GPT web chat to Copilot inline completion, then to the Cursor plugin ecosystem, and finally into the AI Agents era led by Claude Code — in just two or three years, AI coding has leapt from "transactional dialogue" to "autonomous agents." Based on a talk shared by Bilibili creator Hong Ge, this article systematically maps out the AI coding landscape: model capability rankings, mainstream tool camps, and the three most noteworthy weapons of the Agent era — MCP, Skills, and CLI.

The Four Stages of AI Coding Evolution

Looking back over the entire development trajectory, we can clearly divide it into four stages.

Stage One: The Web Chat Era. Starting with ChatGPT, and after the release of DeepSeek R1 and V3, domestic users flooded in en masse. This era solved the problem of "getting AI to do things for us," but the pain points were obvious too: the interaction between humans and AI was "transactional" — you'd paste code into a web page, wait for the AI to process it, then paste it back. Efficiency was limited.

Stage Two: The IDE Integration Era. VS Code and Cursor pioneered inline completion, which could complete code based on comments, but the context was still confined to a single file. It was precisely at this stage that JetBrains began to fall behind, with many long-time subscribers switching over to the VS Code ecosystem.

Stage Three: The Multi-File Plugin Era. Cline, Augment, Cursor Agent, and others integrated deeply with VS Code as plugins, tapping into its capabilities to read files, execute commands, and retrieve memory — giving AI a much deeper understanding of an entire project.

Stage Four: The AI Agents Era (the present). Marked by Karpathy's release of his self-developed Claude Code, AI coding has officially entered the agent-driven stage.

LLM Capability Tiers: Who's Leading the Pack?

Before diving into the tools layer, it's worth first mapping out the overall LLM landscape. Model capabilities have evolved primarily along four threads: context length (1M has become the standard), instruction following (from needing carefully crafted prompts to understanding rough-and-ready instructions), tool calling / function calling capability, and reasoning ability (after DeepSeek R1 was open-sourced, reasoning models sprang up like mushrooms).

First Tier: The U.S. Closed-Source Camp

At the top are still Anthropic's Claude series and OpenAI's GPT-5.6. Among the former "Big Three," Google has fallen behind because Gemini 3.5 Pro was delayed for so long — instead they released 3.6 Flash first, which the community mockingly called "abstract."

Cursor's Composer 2.5 earned a solid reputation because it was post-trained on Kimi K2 (which sparked controversy since it wasn't disclosed). After Grok 4.5 was released, the community reacted enthusiastically — both fast and capable. On balance, the top international tier currently consists of three heavyweights: Claude, GPT-5.6, and Grok 4.5.

The Domestic and Open-Source Camp

In the domestic camp, Kimi K3 has been highly praised for its front-end and design capabilities; Qwen 3 Max drops to as low as a 0.2 discount (a 98% price cut) for nighttime usage. There are also DeepSeek V4 Pro, Doubao Seed Code (updated weekly), MiniMax M3 (whose audio/music generation is a highlight), and more.

One point deserves special emphasis: "domestic" doesn't mean "open-source only" — ByteDance's Seedance 2.0 and the latest Qwen version are both closed-source models. DeepSeek, meanwhile, is regarded as a heavyweight, "Whampoa Military Academy-level" domestic company.

A Full Overview of AI Coding Tool Camps

The division of tool camps roughly corresponds to the model camps, splitting into two major factions: international and domestic.

Mainstream International Tools

To judge who does best, just look at who everyone "benchmarks against":

• CLI category: Claude Code is the benchmark, with Codex trading blows evenly with it
• IDE interface category: Cursor does it best and is the industry's benchmark target
• Built into VS Code: Copilot is deeply bound to VS Code, offers the best project understanding, and already supports third-party model APIs
• Google Anti-Gravity: Released alongside Gemini 3.0, but more users came for the built-in Claude models
• Gemini CLI: Launched by Google after it acquired Cursor, it's been quite hot recently

Domestic and Open-Source Tools

On the open-source front, OpenCode has built-in free models that can be used directly for simple problems; it's developed on the Pi kernel, with the advantage of being extremely lightweight and fast. Its downside is that its Harness constraints are almost nonexistent, so on large projects the model tends to "run wild" and go off track — it's not recommended for large projects.

Domestic tools, meanwhile, are flourishing: Tencent's CodeBuddy/WorkBuddy, Alibaba's Qoder/QoderWork, ByteDance's Trae/TraeWork (all three are benchmarking against office-productivity scenarios), as well as Zhipu's ZCode 3.0 (developed by mimicking the Codex form, far more usable than the shell-like 2.0), Kimi Code, MiniMax Code, and others.

One key takeaway worth remembering: domestic models are almost all deeply adapted to Claude Code — just plug their APIs into Claude Code and you can use them seamlessly and unleash their strongest capabilities. Of course, as each company's in-house IDE matures, the future will inevitably move toward the path of "each company's own IDE being deeply adapted to its own model."

The Three Core Weapons of the Agent Era

This is the part of the entire AI coding system that truly delivers a leap in efficiency. There are really only three tools that genuinely boost productivity in the Agent era.

MCP: Model Context Protocol

MCP (Model Context Protocol) is essentially a protocol: as long as a tool conforms to it, the model can understand and call it. Common ones include Playwright MCP (controlling browsers / web collaboration), Chrome DevTools MCP, database MCP, internal-system MCP, and so on.

But there's an important caveat: more MCP is not better. Too many MCPs crowd out the context, making the model "dumber the more you install," and their uneven quality can actually slow the AI down. Many people install a bunch just because others recommend them, when in reality only two or three are truly used regularly.

Skills: Reusable Skill Packages

A Skill (skill package) is essentially "a set of prompts + scripts + reference materials/documents." Its biggest feature is that it's loaded on demand — it doesn't take up the entire context all at once.

The standard structure is a Skills directory containing a SKILL.md: first write the skill's name and a brief description (used by the AI to decide whether to invoke it), followed by detailed content telling the model which commands and scripts to use, what to do at each step, and what the reference materials are.

A typical case: comparing two enormous JSON configuration files for a calculator chip — comparing them by hand is extremely tedious. Once the process is solidified into a Skill — essentially a piece of Python code with a nested loop comparing them one by one and outputting the differences — the entire team only needs to say "help me compare the calculator differences" to get it done. Skills can be shared with the team and reused across projects, and can also be open-sourced for wider use.

CLI: A Severely Underrated Powerful Tool

CLI is the most easily overlooked of the three weapons. It's essentially a traditional command-line tool (Git, for example, is a CLI), except that modern CLIs are optimized to "be understood by AI" — their interfaces, documentation, and Help info are written out very thoroughly, so once the AI reads them it knows how to invoke them to complete a task.

A typical use case: after integrating the Feishu (Lark) CLI, you can have the AI export documents and read group chat records. For example, if you've joined the official groups of several AI companies, before leaving work you can have the AI use the Feishu CLI to analyze the latest messages in each group and summarize newly released official updates. In addition, DingTalk, Cloudflare, various database platforms, and Notion all have their own CLIs — integrate them into your Agent and you can have the AI directly access data on each platform. A CLI is essentially an HTTP call: it verifies identity and returns structured data for the AI to analyze — extremely efficient.

The Retreat of Heavy Constraint Frameworks

A trend change worth watching: as model capabilities have vastly improved, Harness engineering approaches like Spec-Kit — once all the rage — have actually become a bit superfluous.

Observations show that GPT-5.6 combined with Spec-Kit gets stuck in an endless loop of "invoking sub-agents → sub-agents call Spec-Kit again → generating resources to dispatch sub-sub-agents." The rules and constraints actually limit the performance of a smart model and introduce flawed lines of thinking. As a result, more and more people are starting to uninstall Spec-Kit from Codex, relying instead on the model's own capabilities plus fine-grained optimization of the system prompt.

Model Selection and Multi-Agent Collaboration in Practice

At the implementation level, one pragmatic strategy is: use domestic models for simple bugs, and hand complex bugs to Codex. Two valuable engineering cases for reference:

AI Review Agent closed loop: after code is pushed or an MR is opened, an AI review is automatically triggered and its comments are written back into the MR. A companion Skill then has each repository automatically pull the review comments, hand them to a local AI to understand and fix the issues, and re-push — forming a complete closed loop.

Automated scheduled tasks: every morning, automatically compile the latest news and push it to Feishu/DingTalk; or set up monitoring tasks that watch for production anomalies and automatically push alerts.

Conclusion

Current AI coding is no longer a single question of "which model is stronger," but a three-dimensional engineering system jointly composed of model selection, tool camps, capability extension (MCP/Skills/CLI), and collaboration patterns.

What's intriguing is that as models' own capabilities improve at breakneck speed, the heavy constraint frameworks once so hyped are now retreating — which reminds us that the best practices in AI engineering are always in a state of dynamic evolution. Rather than blindly piling on tools, it's better to understand the applicable boundaries of each weapon and find the optimal solution that works for you.