VCP V-Project Hands-On: 95% Token Cache Hit Rate, AI-Controlling-AI Spiral Programming

In an era where AI coding tools are mired in homogeneous competition, the V-Project module launched by VCP (Video Coding Platform) is trying to answer a more fundamental question: now that AI can write code, how should we organize AI to write code?

In his latest long-form video, a Bilibili creator used a nearly 10,000-word script to break down the V-Project across three dimensions—what makes it good, how to configure it, and real-world cases. The core conclusion is quite bold: this is the strongest coding tool available today, and it leaves the runner-up in the dust.

1. Saving Tokens Is Only the Surface—Cache Hit Rate Is the Key

The most immediate impression of the V-Project is that it is "extremely token-efficient." According to the creator's testing, in a single conversation the cache hit rate stays above 95%; even in a newly opened conversation, the hit rate is quite high.

He showed his usage records: a week filled with 180K and 190K token consumption entries. "I'm certain that must have been coding, otherwise you basically couldn't use that much." Contrast this with his earlier experience using Codex, where "two accounts burned through a weekly quota in three days." After switching to the V-Project, a single Pro account's quota was more than enough.

This saving doesn't come from compression alone—it stems from a completely different code lookup logic. Native CLI tools typically locate targets by reading a line, several lines, or an entire block of code, often requiring multiple tool calls. The V-Project instead uses a positioning scheme based on coordinates plus trace—the creator admits he doesn't fully understand the specifics, but the effect is that "if there are no duplicate functions or deep nesting, it basically locates instantly." The drastic reduction in lookup count directly drives down token consumption.

Token cache hit rate is a key metric for the economic efficiency of LLM API calls. Major model providers (such as Anthropic, OpenAI, and Gemini) all support prompt caching: when the request prefix heavily overlaps with a previous call, the server can directly reuse the already-computed KV cache and bill at a price far below normal input. The higher the hit rate, the lower the cost of repeatedly reading the same codebase. For coding scenarios that require repeatedly reading large context files, cache hit rate often determines actual cost more than the per-token unit price. This is also why the V-Project emphasizes moving the injection point of the reasoning chain later—any dynamic content placed in the cached prefix invalidates all subsequent caching.

2. Engineering: Laying Out the Development Lineage for You

At the engineering level, the V-Project goes further than the "mainline branch commit archive" mentioned in the previous video. The entire development lineage, changed files, which Agent made each change and why, along with a complete todo list report, are all presented directly.

The creator showcased a case of upgrading the stability of automated product selection: 15 todo items, 129 changed nodes, 47 files involved, over 2,000 lines changed and over 300 lines deleted. Clicking "Development Lineage" reveals all 129 nodes from B2 990 to B3 126 at a glance. Opening any node shows exactly what the file did at that step, why the change was made, and the specific code diff—all directly viewable. It even supports undoing changes and restoring to a previous version.

In the changed-file list, the number of lines added and removed for each file is clearly annotated. Since the V-Project supports multiple execution Agents, you can also see the division of labor—the creator set up three Agents: the master Agent made over 100 changes, while the worker Agents made over 40. Acceptance reports, Git commits, and pushes are all integrated into the same interface.

Agent here refers to an AI execution unit given a specific role, tool permissions, and system prompt. Unlike traditional single-turn conversations, an Agent can autonomously plan steps, call tools (read/write files, execute commands), observe results, and iterate until the goal is complete. Multi-Agent systems typically adopt a division-of-labor architecture: a "master" responsible for planning and review, plus several "worker" units responsible for concrete execution, collaborating via message passing or shared state. This architecture reduces the burden on any single context window, but it also introduces engineering complexity around communication protocols, task dispatch, and conflict coordination—which is precisely the main source of the V-Project's configuration barrier.

3. Left Foot on Right Foot: AI-Controlling-AI Spiral Programming

This is the most information-dense and noteworthy part of the entire video. The creator had previously said his product-selection tool had hit his "personal capability ceiling," but the V-Project let him use AI to control AI—even groups of AI controlling other groups of AI—breaking through that limit.

The specific case is a front-end overhaul of the automated product-selection report. The old version was a pure Markdown document—text-heavy and hard to read; the new version is a standalone HTML report with full animations, where every tag is clickable, sections are independent and reorderable, and all data sources are fully utilized.

The key point: the creator only gave three requirements—each section independent, must have animations, and fully utilize the data sources. After that, the system ran autonomously for two to three hours, consumed 30 to 40 million tokens (less than 100 million), and produced a complete front-end with nine sections and ten display panels. He said bluntly: "With my personal front-end, design, and coding abilities, it would have been impossible for me to build something like this."

This approach relies on a clear division of labor between two Agents:

• Master Agent (Kurt): handles conversation, planning, integration, and code review, using strong models like Gemini 3.8 or Astra.
• Worker Agent (Code): only takes the construction blueprint and writes code, without participating in design discussions. The creator offered an analogy: "It's like hiring a very skilled bricklayer and asking him to discuss house design with you—that's obviously wrong."

The two collaborate via VCP's AA plugin for communication, combined with an action lock (flow lock) mechanism, allowing a fully planned project to run completely hands-off. The creator demonstrated the full workflow: the master writes the todo list, he starts construction in a new conversation, the worker Agent completes a stage task and triggers the next round via a placeholder reply, and it advances automatically once a checkpoint passes.

In the locked state, everything has high cache hit rates, so two Agents doing the same thing doesn't cause excessive waste—even though one has to read the code to write it while the other has to read it to review, so the code is inevitably read twice.

Action lock (flow lock) is a process-control mechanism: after the master Agent finishes planning and generates the construction blueprint, the system enters a locked state and automatically advances the worker Agent's rounds according to preset checkpoints, without requiring human confirmation each round. The key lies in checkpoint acceptance—after the worker Agent completes a stage task, it must trigger the next round via a placeholder reply or acceptance condition; if it fails, it stays at the current node. This mechanism strings "planning—construction—acceptance" into a hands-off pipeline, while relying on high cache hit rates to offset the extra cost of two Agents reading code repeatedly.

4. Configuration Barrier: The Complex Cost Behind the Power

The creator did not shy away from the V-Project's configuration complexity. He demonstrated the full workflow in the video, and several key steps are worth noting:

1. Configure the workspace: Add a working directory in global settings. Linux is currently unsupported, so you need tools like Mutagen for two-way sync, and you must specify newline conventions and other rules in the prompt.
2. Register Agents: Both the master and worker Agents need coding capabilities, each with its own system prompt.
3. Adjust the tool-call loop limit: The VCP config file defaults to 5–6 loops; for coding scenarios, at least 50 is recommended to avoid hitting the ceiling on complex code.
4. Set Agent communication config: The default communication limit is low—the creator raised it to 30; the delegation timeout was changed from the default 30 minutes to 45 minutes.
5. Context injection: Use the "Tavern" plugin or front-end to inject management rules. The creator specifically moved the reasoning chain injection point from the top to the end of the user message, reasoning that "the reasoning chain is normally at the top, and since the injected content differs each time, it's very easy to miss the cache"—placing it later saves more tokens.

He repeatedly emphasized one judgment: the V-Project feels more powerful than the memory system, but the price of that power is the need to master a great deal of foundational AI knowledge "to get the most out of the model."

5. Limitations and Outlook

The V-Project is not without shortcomings. The lack of Linux support is a clear functional gap; AA plugin communication "still seems a bit buggy," requiring the creator to write placeholders in the system prompt as a safeguard; and he himself is still studying the group collaboration mode, admitting "I don't fully understand it myself."

But he is quite confident about the product direction: from the strongest memory system to the V-Project, V-Workshop, ROM 2.0, and potentially a refined V-Desktop, Zhizi's vision is to normalize all traditional tool workflows into VCP. "At least at my level, I basically can't use any other AI tools anymore."

For developers who want to try it, the creator's advice is direct: if you're using the V-Project, use good models. His server's New API connects to more than 20 channels, covering Qwen, Zhipu, Ollama, NVIDIA, Xiaomi, and several third-party Gemini channels. "With poor models, you might not even be able to invoke VCP tools properly, let alone get good results."

As for true "wish-driven development"—giving a vague, abstract requirement and letting multiple Agents discuss among themselves to clarify boundaries before autonomously starting work—the creator sees this as the ultimate form of group collaboration, but it involves many unsolved problems such as planning boundaries, inter-Agent communication standards, and construction blueprint dispatch. He plans to share more once he has studied it thoroughly.

One-line Summary

The V-Project combines a 95% cache hit rate with AI-controlling-AI spiral programming, claiming to be today's strongest coding tool.

Paragraph Summary

Based on a nearly 10,000-word Bilibili video, this article breaks down the VCP platform's V-Project module across three dimensions. Its most obvious advantage is extreme token efficiency: over 95% cache hit rate in single-turn conversations, driven by coordinate-plus-trace sub-second code localization that drastically reduces tool calls. On the engineering side, 129 development nodes, 47 changed files, multi-Agent division of labor, and acceptance reports are all visualized, with undo and version restore supported. The core highlight is AI-controlling-AI spiral programming: the master Agent plans and reviews while the worker Agent only builds to the blueprint, and with the action lock it can run fully hands-off—a front-end overhaul with only three stated requirements ran autonomously for hours and consumed tens of millions of tokens. But the configuration barrier is high: loop limits must be raised to 50, communication count to 30, and reasoning chain injection position optimized; Linux support is missing and the AA plugin still has bugs. The author is confident in its direction and recommends pairing it with strong models.