Gained 25K Stars in One Week: This Chinese Open-Source AI Coding Tool Takes on Claude Code

An Open-Source AI Coding Tool Rises to Prominence

At a time when Claude Code has nearly dominated the terminal AI coding space, a Chinese open-source project has quietly emerged—gaining 25,000 GitHub Stars in just one week and attracting widespread attention from the developer community. The tool's positioning is crystal clear: it writes your code, fixes errors, runs tests, and manages versions. You hit enter with one sentence, and it handles everything else.

Terminal-based AI Coding Agents are AI programming assistants that run directly in the command-line environment. Unlike IDE plugin-style Copilot tools, they use the command line as their primary interface and can directly execute system commands, read/write files, and run scripts. Claude Code, released by Anthropic in 2025, is the flagship representative of this category, quickly capturing market share thanks to Claude's powerful code comprehension capabilities. The advantage of terminal tools lies in their seamless integration with developers' existing command-line workflows—no need to switch IDE environments—making them particularly suited for backend development, DevOps, and system administration scenarios.

In today's landscape where AI coding assistants are blooming everywhere, gaining this level of attention in such a short time proves it has genuinely hit developers' pain points. So what exactly makes this tool unique?

Core Capability: Fully Autonomous Closed-Loop Programming

Automated Workflow

The tool's biggest highlight is its complete automation closed loop. Traditional AI coding assistants often require developers to constantly intervene at intermediate steps—copying error messages, manually pasting them into chat boxes, then applying suggested fixes to the code. This tool's workflow is:

1. Read files and analyze code structure
2. Review error messages and locate root causes
3. Modify the code
4. Automatically run tests
5. If tests fail, feed the errors directly into the next iteration
6. Repeat until the problem is solved

The Autonomous Loop is a core concept in the AI Agent field, originating from feedback loop theory in cybernetics. In programming scenarios, a closed loop means the AI not only generates code but also observes execution results, analyzes error messages, and autonomously iterates corrections based on feedback. This is fundamentally different from the traditional "generate-copy-paste" model. Technically, the tool needs: file system read/write permissions, Shell command execution capability, output parsing ability, and the ability to re-inject error information into the reasoning context. This pattern is also known as the ReAct (Reasoning + Acting) framework, which is the mainstream architecture for current AI Agents.

The entire process forms a complete closed loop—developers only need to describe their requirements in one natural language sentence, and the tool handles the rest autonomously.

Million-Token Context Support

For large projects, this tool supports a million-level context window, allowing an entire project to be fed in for analysis at once. This means it doesn't just make modifications at the single-file level—it can understand the project's overall architecture and inter-module dependencies, solving problems from a global perspective.

The Context Window is the maximum text length a large language model can process at once. Early models like GPT-3.5 only supported 4K tokens, while million-level context means being able to process approximately 750,000 words of text simultaneously. For programming scenarios, a medium-sized project might contain hundreds of source files and tens of thousands of lines of code. Traditional short-context models can only analyze files one at a time, easily losing cross-file dependency relationships. Million-level context allows the tool to take the entire codebase as input, understanding call chains between modules, interface contracts, and data flows, thereby making more accurate global modifications. Google's Gemini series and some open-source models have already achieved this capability.

Parallel Tasks and Checkpoint Resume

Multi-Task Parallel Processing

When facing complex tasks, the tool automatically breaks them down into multiple subtasks (up to 10) and executes them in parallel simultaneously. Each subtask completes independently, then results are aggregated and integrated. This parallel architecture dramatically improves efficiency when handling complex requirements.

Parallel task processing draws from the MapReduce concept in distributed computing: decomposing (Map) a complex task into multiple independent subtasks, executing them in parallel, then aggregating (Reduce) the results. In AI Agents, this is typically implemented through multiple independent reasoning instances, each handling one subtask with its own context and tool-calling permissions. For example, when refactoring a feature spanning frontend, backend, and database, the tool can simultaneously launch three sub-Agents to handle modifications at each layer, with a master Agent coordinating the final merge. The challenge of this architecture lies in dependency management and conflict resolution between subtasks.

Checkpoint Resume Mechanism

Interruptions are inevitable during development—closing the terminal, shutting down, network disconnections. This tool provides checkpoint resume capability: the next time you open it, execution automatically continues from where it left off, without losing any progress.

Snapshot Rollback

What if the code gets broken? The tool takes a snapshot at every step—one command rolls back to the state before the modification, leaving the Git history untouched. This gives developers full confidence—let the AI experiment boldly, and roll back anytime if things go wrong.

The technical implementation of Checkpoint Resume typically relies on serializing the Agent's complete state—including conversation history, list of executed operations, current task progress, file modification records, etc.—to local disk storage. When a session resumes, the tool reads the state file to rebuild the execution context. Snapshot rollback is similar to database transaction logs or the Copy-on-Write mechanism in file systems: saving a copy of the original content before each file modification, and directly restoring it during rollback. Unlike Git version control, these snapshots are managed internally by the tool and don't pollute the project's Git commit history.

Intelligent Model Routing and Extensibility

Automatic Model Selection

Unlike tools that require manual model selection, this tool has a built-in intelligent routing mechanism: simple questions use lightweight models (saving money), while complex tasks automatically switch to more powerful models for full processing. Developers don't need to worry about which model is being used underneath—the tool determines the optimal approach on its own.

Intelligent Model Routing is a cost optimization strategy whose core idea is "use the right model for the right job." Technically, the tool typically uses a lightweight classifier (or rule engine) to first assess task complexity—simple tasks like code formatting or variable renaming are routed to small models (e.g., GPT-4o-mini), while tasks involving complex architectural design or multi-file refactoring call upon flagship models. OpenAI's Router API and open-source projects like LiteLLM provide similar capabilities. This strategy can reduce API call costs by 50%-80% while maintaining output quality—significant economic benefits for high-frequency users.

Transparent Reasoning Process

The entire reasoning process is streamed in real-time, allowing developers to clearly see how the tool breaks down problems and makes decisions. This transparency not only builds trust but also makes it convenient to intervene manually when necessary.

Highly Extensible

The tool supports extension across three dimensions:

• External tool connections: Integration with existing development toolchains
• Custom skill packs: Tailored capabilities based on team needs
• Local deployment: Meeting data security and privacy compliance requirements

However you design your workflow, it runs accordingly. This flexibility is particularly important for enterprise-level use cases.

Differentiated Competition with Claude Code

From a positioning perspective, the core differences between this tool and Claude Code are:

Feature	This Tool	Claude Code
Open Source	✅	❌
Local Deployment	✅	❌
Parallel Tasks	✅	Limited
Checkpoint Resume	✅	Partial Support
Automatic Model Routing	✅	Single Model

As a Chinese open-source project, it has natural advantages in data privacy, deployment flexibility, and cost control. The growth rate of 25K Stars in one week also demonstrates the developer community's strong demand for this type of tool.

Summary

This tool represents an important evolutionary direction for AI coding assistants: from "assistance" to "autonomy," from "single-turn conversations" to "closed-loop execution." It's no longer just a smarter code completion tool—it's an AI Agent capable of independently completing programming tasks. For developers who prioritize efficiency, it's worth watching and trying out.

Key Takeaways

• A Chinese open-source AI coding tool gained 25K GitHub Stars in one week, directly competing with Claude Code
• Its core capability is fully autonomous closed-loop programming: writing code, fixing errors, running tests, and managing versions end-to-end
• Supports advanced features including million-level context, parallel subtask decomposition, checkpoint resume, and snapshot rollback
• Built-in intelligent model routing automatically assesses task complexity to select appropriate models, balancing cost and performance
• Supports local deployment, external tool connections, and custom skill packs with strong extensibility