Cursor Pro Discontinued, Claude Code Cost Savings, and Five Major AI Coding Developments

AI coding tools are undergoing a dense round of product and pricing adjustments. Bilibili's "Programming Top 5" covered five major developments over two days—from Cursor's subscription being folded into X and Claude Code's automatic context compression, to GitHub Copilot's multi-model orchestration and Alibaba Qoder opening agent teams to individuals. Nearly every one points to the same trend: the competitive focus of AI coding is shifting from "who can write code" to "who can manage code and costs well."

1. Cursor Pro Discontinued: The $20 Tier Becomes History

According to Bilibili creator "Programming Top 5," Cursor is folding its subscriptions into the X system, canceling the original $20 Pro tier. The new tier structure is roughly: the $8 tier supports only Grok; using Claude or GPT models requires at least the $30 tier; higher usage is billed separately at API prices.

This means the cost-effectiveness window for individual developers to "get all models with one subscription" is closing. For users who rely on Cursor to write code, the migration cost isn't just paying more—it's re-adapting prompt habits, keyboard shortcuts, and project configurations.

2. Anthropic Builds Its Own Version Control: The Bottleneck Shifts from Writing Code to Managing Code

Anthropic was reported to have built its own version control system using Git. Daily code merges reportedly grew from 2,500 in May to over 30,000 in September. A team of seven completed the onboarding process in five months at a cost 200x lower than conventional solutions.

The value of this figure isn't "saving money"—it's the signal it reveals: when the volume of AI-generated code rises sharply, the real bottleneck shifts to code merging, review, and version management. The next wave of opportunity in the toolchain is likely to appear in "managing AI output" rather than "generating AI output."

3. Claude Code Auto-Compresses Context: Long Conversations Save Money Directly

Claude Code added idle automatic compression: when a 200K-token conversation sits idle for about 54 minutes, the system automatically compresses the context before the cache expires. Cache reads cost as little as 5%, while expired rewrites cost double—so the cost difference in long-conversation scenarios is significantly amplified.

For teams that frequently run long tasks with agents, this is an underrated optimization—it turns "context management" from a manual developer action into default behavior, saving not just money but also the attention drain of frequently resetting conversations.

Prompt Caching is the key mechanism for understanding the cost difference in this section. LLM APIs reprocess the full context on every request, and this overhead grows linearly in long conversations. Caching lets providers temporarily store already-processed context prefixes in VRAM or high-speed storage, so the next request that hits the cache can skip redundant computation—which is why reading from cache is far cheaper than the initial write. Anthropic's cache has a clear lifecycle, typically expiring after about 5 minutes without requests; using it again after expiration incurs the write price. This is exactly why auto-compression must trigger "before the cache expires"—compressing a 200K-token long history into a shorter summary both avoids the high cost of expired rewrites and reduces the tokens carried in each subsequent request.

4. GitHub Copilot Multi-Model Orchestration: Cheap Models Draft First

GitHub Copilot launched Hybrid Fusion, a multi-model orchestration capability: a cheap model drafts first, a judge model reviews, and unsatisfactory results are escalated to a strong model. Official estimates suggest this strategy can save up to 67% in costs, but it remains a research preview and is not recommended for direct production use.

The trade-off here is clear: cost and stability haven't both met the bar yet. Teams willing to accept some output variance can experiment first, but production pipelines should still retain human review or strong-model fallbacks.

Model Orchestration / Routing refers to dynamically dispatching models of different sizes and price points within a single request flow based on task difficulty. A common approach is to let smaller models handle low-difficulty steps like drafting, completion, and format conversion, then have strong models review, correct, or rewrite. The economic basis is that per-million-token prices can differ by more than an order of magnitude across models, while most coding requests don't require top-tier reasoning. The cost is a longer pipeline, increased latency, and extra validation overhead when small models err—which is why such solutions are often released first as research previews in official messaging, and only recommended for production once evaluation metrics stabilize.

5. Alibaba Qoder Opens Agent Teams: Switching Costs Are Falling

Alibaba Qoder^Ad has opened its agent team capabilities to the personal edition. The company claims Fast mode response time dropped from 8 seconds to 3 seconds with 27% fewer tokens; it also supports importing WorkBody tasks and skills, further reducing tool migration friction.

This forms an interesting contrast with Cursor's price hike: one side is raising per-user prices, the other is lowering entry and migration barriers. For developers, using multiple tools and switching by task scenario may be more cost-effective than sticking to a single subscription.

Agent Team differs from a single conversational coding assistant in its division of labor: multiple agents with independent roles and tools handle requirements decomposition, coding, testing, and review respectively, coordinated by a scheduling layer that manages each other's inputs and outputs. This architecture can handle cross-file, multi-step engineering tasks, but places higher demands on context passing and tool-calling protocols. So-called "skill import" essentially reuses existing tool definitions and task templates, so users don't have to rebuild workflows from scratch—lowering the sunk cost of switching tools. This is the technical source of the reduced migration friction mentioned in the article.

Cross-Source Observation: The Same Thread Behind All Five Developments

According to analysis from the Bilibili creator and multiple developer communities, these five developments fall into three categories of signals: pricing restructuring (Cursor tier changes), engineering catch-up (Anthropic version control, Claude Code context compression), and cost optimization competition (Copilot multi-model orchestration, Qoder response speedup).

One point of disagreement: whether Cursor folding into X subscriptions means long-term ecosystem integration benefits, or individual developers being forced to accept higher prices. Optimists believe bundling multiple products can dilute costs; the cautious believe the disappearance of the $20 tier directly raises the entry barrier. There's no conclusion yet—we need to watch whether tiers are adjusted back.

A relatively firm consensus: competition among AI coding tools has entered the stage of competing on "cost per task." Whoever can keep output quality while driving down tokens, response time, and tool migration costs is more likely to retain developers.

Conclusion

Among the five developments, none is simply "the model got stronger." Cursor is adjusting prices, Anthropic is managing code, Claude Code is saving cache, Copilot is orchestrating models, and Qoder is lowering barriers—the main battlefield of this competition has shifted from model capability to engineering efficiency and cost structure. For developers, the most practical advice is: regularly recalculate the unit cost of your toolchain, and don't let subscription inertia make choices for you.