Zhipu ZCode 3.0 Hands-On Review: A Deep Dive into the Native GLM-5.2 AI Coding Tool

Overall Positioning: Natively Built for GLM-5.2

With Zhipu AI launching its next-generation model GLM-5.2, the companion AI coding tool ZCode has received a fully rebuilt 3.0 release. Based on hands-on testing shared by a Bilibili creator, this tool takes heavy design inspiration from what is currently the gold standard in AI coding — Claude Code (referred to below as "Class F") — while making deep adaptations for Chinese users and Zhipu's own model ecosystem. This article offers a comprehensive breakdown of ZCode's features, highlights, and shortcomings.

ZCode's official website explicitly positions it as an "AI coding tool deeply optimized for Zhipu's 5.2 model." It currently supports Mac and Windows, with Linux support still in development. The main interface layout closely mirrors Class F — a project list on the left, a conversation panel in the center, and an input box where users can type instructions and invoke skills directly.

Technical Background on GLM-5.2: The GLM (General Language Model) series is a family of large language models developed by Zhipu AI, incubated from Tsinghua University research. It uses a proprietary autoregressive blank-filling pretraining framework, which differs from the unidirectional autoregressive architecture used by GPT-series models. GLM-5.2 has been specifically optimized for code generation, long-context understanding, and Chinese-language processing. Compared to third-party coding tools that rely on OpenAI or Anthropic APIs, ZCode — as the native companion tool — theoretically allows for deeper co-optimization with GLM-5.2 at the level of prompt engineering, context window utilization, and tool-calling protocols. This is the core value proposition behind the "deep adaptation" positioning. For Chinese developers, using a domestic model also means lower network latency and more reliable service availability.

One notable detail: ZCode is not a brand-new product. Previous versions existed but were reportedly "extremely difficult to use." The 3.0 release is a ground-up rebuild. The strategy of benchmarking against a mature product both confirms Class F's status as the industry standard and gives ZCode a strong usability baseline right out of the gate.

Why Claude Code Is the Industry Benchmark: Claude Code, developed by Anthropic, derives its core advantage from deeply integrating the "Agentic Coding" paradigm — meaning the AI doesn't just generate code snippets, but proactively reads project file structures, executes terminal commands, debugs errors, and maintains contextual coherence across multi-step tasks. This is fundamentally different from earlier tools focused purely on code completion (such as early versions of GitHub Copilot). Claude Code's plugin ecosystem allows developers to extend capabilities via MCP (Model Context Protocol), connecting external services like browser control, database queries, and API calls — creating a closed loop that covers the entire development workflow. This is precisely the area where ZCode has the most ground to make up.

Permission Modes and Model Management

ZCode offers tiered permission controls: at the lowest level, all file changes require user confirmation; an elevated level allows automatic file editing; and there are also a planning mode and a full-access mode, all switchable via keyboard shortcuts.

For model management, ZCode supports two ways to connect to Zhipu's models — a coding subscription plan and an API Key method — and also allows adding third-party providers. When adding a custom model, users fill in the name, request URL, API Key, and format. Currently, Claude and OpenAI API formats are the two primary options, with the Claude format generally recommended.

However, there is a notable gap in the thinking-level settings: ZCode currently only offers two options — "no thinking" and "maximum" — with no low or mid-level options. The Relationship Between Thinking Level and Token Consumption: This setting corresponds to controlling the depth of "Chain-of-Thought" reasoning in large language models. When deep thinking is enabled, the model performs extensive internal reasoning steps before generating its final output, and these intermediate steps also count toward token usage. For complex tasks like algorithm design or architectural decisions, deep thinking can significantly improve output quality. But for simple tasks like code formatting or variable renaming, forcing maximum thinking level wastes resources — both increasing user costs and extending response time. Industry-standard implementations (such as Cursor's model selection mechanism) typically offer 4–5 granularity levels, and some even support automatic adjustment based on task complexity. The absence of intermediate levels means users may be forced to burn a large number of tokens on trivial tasks. A proper low/medium/high/maximum gradient is still needed here.

Skills and Plugin System

ZCode invokes skills via the slash "/" command, and users can browse available skills in the skill list. These skills come from global directories (such as the .claude directory or .agent directory), and can be imported from external agent directories like Claude Code or OpenCode, or created from scratch.

Beyond skills, ZCode introduces a "plugin" concept, invoked via the dollar sign "$". However, this is one of the most visible shortcomings of the current version.

What makes Class F so powerful is not just the model itself, but its remarkably rich plugin ecosystem spanning coding, work, productivity, design, and more. The Underlying Architecture of AI Coding Tool Plugins: The plugin system ZCode references is closely related to MCP (Model Context Protocol), a standard that is rapidly gaining traction across the industry. MCP is an open protocol proposed by Anthropic in late 2024, designed to standardize the communication interface between AI models and external tools and data sources — analogous to USB ports for hardware devices. Through MCP, AI coding tools can connect to browser automation (e.g., Playwright), file systems, databases, and third-party APIs, extending the model's text generation capability into genuine "computer operation capability." For ZCode to close the gap with the benchmark product, building a mature MCP plugin marketplace — including standardized plugin descriptions, permission explanations, and one-click installation — will be the core path forward, rather than simply increasing the number of plugins.

As an early-stage release, ZCode currently has a very limited plugin selection and lacks detailed plugin pages — users cannot clearly understand what each plugin does or when it gets triggered. Additionally, skills and plugins are not visually distinguished in the interface, which can easily cause confusion and warrants improvement.

Delivery Behavior and Index Library

In practice, ZCode's "Delivery Behavior" settings are a genuine highlight, offering two modes:

• Queue (Chain) Mode: New input is queued after the current task, replacing it immediately upon submission.
• Guidance Mode: New input is injected into the currently running task as a branching input that participates in ongoing reasoning, without immediately replacing the current task.

The Engineering Logic Behind Guidance Mode: ZCode's "Guidance Mode" corresponds to an interaction mechanism in software engineering known as "Task Injection" or "dynamic context injection." In traditional request-response models, each user input either replaces or is appended to the end of the conversation queue. Guidance Mode allows new instructions to be embedded into an actively running inference flow as a "branching participant" — similar to inserting a quality-check requirement mid-way through a factory assembly line, rather than waiting for the entire line to finish before starting over. This design is especially critical for long-running agentic tasks: when an AI is executing a complex task that takes 30–60 minutes, users can course-correct in real time without completely interrupting and restarting the process, dramatically improving human-AI collaboration efficiency. This is also one of the core interaction design philosophies that distinguishes an "AI coding assistant" from an "AI coding agent."

Testing confirms that Guidance Mode is highly practical during long-running tasks. For example, while the AI is scanning a project, the user can inject guidance like "pay attention to any payment logic you find," and the system incorporates that instruction into its ongoing reasoning, influencing subsequent execution. There is one minor UX issue: switching between delivery behaviors (queue/guidance) does not take effect immediately — there is a noticeable delay before the change kicks in.

Another practical feature is the Index Library, which is recommended to keep fully enabled. The Technical Principle Behind the Index Library: At its core, it builds a local vector-based semantic index of the codebase — parsing all project code files into chunks, converting them into high-dimensional vectors via an embedding model, and storing them in a local vector database. When the AI needs to locate relevant code, it can perform semantic similarity search (rather than line-by-line scanning) to quickly find target code segments, significantly reducing the token overhead required to pass context into each conversation. This technology is well-established in the RAG (Retrieval-Augmented Generation) domain. For large-scale projects with tens of thousands — or even hundreds of thousands — of lines of code, the Index Library can multiply code retrieval efficiency while preventing critical logic from being missed due to context window limitations. It is a standard capability for AI coding tools handling enterprise-grade projects.

Go Mode and Mobile: Highlights and Gaps

ZCode's official website prominently features Go Mode — setting a goal and letting the AI execute automatically. Both Class F and Claude Code have equivalent functionality. The Bilibili creator demonstrated a cross-language code migration task; Go Mode had been running for 43 minutes, automatically allocating 12 subtasks and completing them one by one.

In Class F, Go Mode is exceptionally capable — once a specific goal and verification conditions are set, the user can essentially step away entirely. This is the ultimate expression of the Agentic Coding paradigm: the AI autonomously plans task decomposition, selects tool-calling paths, handles intermediate errors, and continues pushing forward, forming a complete self-executing loop. Based on testing, however, ZCode's Go command still lags behind Class F by a meaningful margin. Continued improvement in future updates is expected.

Mobile Remote Collaboration

One standout feature of ZCode is mobile support. Users can scan a QR code to jump to a web-based version, where they can view running projects and send commands from their phones — with an experience consistent with the desktop version. This provides genuine convenience for "away from the computer" remote coding scenarios. The design philosophy complements Go Mode well: after launching a long-running automated task on mobile, users can monitor progress and send guidance interventions in real time without being tied to their desktops.

However, the mobile version currently has a notable limitation: users cannot create new workspaces. Since the mobile interface cannot control the desktop to open a specific project, it can only start new conversations within already-running projects on the desktop side — which is functionally quite limited.

Summary: Solid Framework, Distinctive Features Still Developing

Overall, thanks to its adoption of Class F's mature interaction design, ZCode delivers a quite smooth experience. As the native companion tool for GLM-5.2, it already offers a complete functional framework spanning permission management, delivery behavior, the index library, Go Mode, and mobile collaboration.

But to become a truly excellent AI coding tool, ZCode still needs to address several key areas:

• Thinking Levels: More granular options are needed (at least 4 levels recommended) to avoid burning large amounts of tokens on simple tasks;
• Plugin Ecosystem: Urgently needs to enrich its plugin library based on MCP standards, with detailed plugin pages, enabling plugins to genuinely control the computer, browser, or enhance development workflows;
• Interface Labeling: Skills and plugins need clear visual distinction to reduce cognitive load;
• Go Mode: The AI's ability to autonomously plan task decomposition and recover from errors still needs to catch up to the benchmark product to further raise automation quality.

The ultimate goal of a great AI coding tool is to let developers handle every stage of development within the tool itself — from requirements analysis and code generation to testing, verification, and deployment — forming a complete autonomous execution loop. Learning from best-in-class products is the right direction for ZCode, but what matters more is building on that foundation to develop its own distinctive strengths — particularly in Chinese-language context optimization and integration with China's domestic development ecosystem (such as connecting with mainstream domestic CI/CD platforms and cloud providers). For Chinese developers, this is still a new tool worth downloading and trying out.