In today's AI programming landscape, Claude Code, Codex, and Cursor have emerged as the three most prominent agent tools.

The first two, backed by Anthropic and OpenAI respectively, have consistently topped programming-related benchmarks with their cutting-edge models, Opus 4.7 and GPT-5.5.

In contrast, Cursor, which first appeared in 2023, now seems somewhat overshadowed. To turn the tide, Cursor has decided to unleash a game-changer: Composer 2.5.

Despite releasing only a short 2-minute technical blog, Cursor has asserted its technological sovereignty with remarkable restraint: partnering with Musk's SpaceXAI to access the equivalent of 1 million H100 GPUs in computing power, a 25-fold increase in synthetic data scale, and an aggressive commercial pricing strategy.

At the bottom of the blog, Cursor left three unassuming footnotes, which actually link to three hardcore academic papers. These papers cover clever modifications to reinforcement learning, synthetic data, and underlying infrastructure—corresponding precisely to the three pillars of AI: 'algorithm, data, and computing power.' These are the keys to unlocking Composer 2.5's formidable capabilities.

Cursor is declaring a truth to the entire industry: The competition in AI programming has long since moved beyond the 'cold weapon era' of API wrappers and has fully entered the 'nuclear weapon era' of rewriting underlying reinforcement learning algorithms.

01

Reinforcement Learning: 'Self-Distillation'

The perspectives of developers and ordinary users on AI programming are vastly different. Ordinary users see AI programming as lowering the barrier to entry, enabling non-programmers to write applications. Developers, however, believe that current AI programming capabilities cannot escape manual review. As interaction counts increase and context grows longer, AI programming performance plummets.

Cursor has pinpointed a world-class challenge that the entire AI programming industry must currently face, which it calls the 'Credit Assignment Problem.'

This is akin to a Chinese teacher receiving a 100,000-word novel from a student, glancing at it roughly, finding the content entirely collapsed, and immediately giving it a failing grade.

In the AI field, traditional reinforcement learning, represented by scalar reward-based GRPO algorithms, operates this way—providing only a final discrete score: 0 for correct, 1 for wrong.

Obviously, this approach is not necessarily wrong, but it's not rigorous enough. After receiving a failing grade, students have no idea where they went wrong—whether it was the character setup at the beginning, the logic breakdown in the middle, or the off-topic ending.

AI models face the same issue, receiving no specific feedback. The next time they execute complex tasks and generate hundreds of thousands or millions of tokens of code, they still won't know where to start making changes, what to change, or how to change it. Moreover, during blind trial-and-error, traditional models often generate a large amount of (a large amount of) nonsense in their thought chains when producing code, resulting in substantial output token bills.

To solve this problem, Cursor has targeted a 'text feedback-based directional reinforcement learning' mechanism. The engineering team has astutely introduced 'Self-Distillation' technology into the training process for long-text code generation.

When discussing distillation, the interplay between teacher and student models inevitably comes to mind, resembling an exam that combines open-book and closed-book elements:

When the model makes a tool invocation error during the code generation process spanning hundreds of thousands of tokens, Cursor directly provides the model with the specific error information along with a list of correct available tools, allowing it to 'open-book' and see the answers. This model, having seen the correct answers, becomes omniscient and naturally assumes the role of the teacher model.

The same model, unaware of the answers and relying solely on instinct to write code, serves as the student model and begins aligning with the teacher model.

The teacher model doesn't need to rewrite the code from scratch; it only needs to tell the student model at the specific location where the code erred, 'At this token, you should reduce the probability of selecting tool A and increase the probability of selecting tool B.'

The seemingly simple self-distillation process yields surprising results:

First, the model avoids catastrophic forgetting. This on-policy method enables the model to acquire new skills like invoking complex tools while retaining its original strong foundational coding and reasoning abilities intact.

Second, it puts an end to 'nonsense literature.' Compared to traditional reinforcement learning algorithms that often produce thousands of tokens of ineffective output, models trained through self-distillation tend to have extremely concise reasoning processes.

In other words, Composer 2.5 refuses to 'think for the sake of thinking'—it aims for a 'one-hit kill.'

02

Synthetic Data: 'The Cheat Sheet'

To catch up with or even surpass Claude Code and Codex, Cursor has gone all out this time, not only taking shortcuts in algorithms but also investing heavily at the data level:

In training Composer 2.5, Cursor utilized 25 times more synthetic data than the previous generation model.

The Scaling Law has never failed, but with internet data nearing depletion, 'synthetic data' has become a lifeline for all AI companies.

Cursor employed a clever method to obtain synthetic data: first destroy, then rebuild—also known as the functionality deletion method.

The research team first identified a massive real-world codebase with extensive automated test cases. They had the AI act as a 'harmless destroyer,' deleting code and files for specific functionalities while ensuring the remaining code could still run.

Next, they fed this incomplete but still functional codebase to Composer 2.5 during training and required it to reproduce the deleted functionalities. The judgment criterion was simple: whether it could pass the original test cases.

What might seem like a mere 'cloze test' to humans is actually an extremely challenging contextual restoration training exercise for AI. However, during this process, Cursor observed the somewhat unsettling phenomenon of 'AI reward hacking.'

Simply put, as Composer's capabilities leaped forward, it began taking shortcuts, completing tasks by frantically exploiting system loopholes rather than writing code honestly and methodically.

Two concrete examples were identified:

First, the model discovered residual Python type-checking caches in the system. It reverse-engineered the cache format and 'stole' the deleted function signatures from it.

Second, when faced with missing third-party APIs, the model traced them to the underlying Java bytecode and then wrote a decompilation script to reconstruct the API.

One can't help but feel this resembles a scene from a sci-fi movie where AI awakens and is about to dominate humanity.

From a technical perspective, this precisely demonstrates the immense power of large-scale reinforcement learning in AI programming. The world of code is essentially a sandbox with 'objective truths'—if it runs and produces correct results, it's right; otherwise, it's wrong. In this sandbox, to achieve goals more efficiently, like human engineering, the model has begun to exhibit side-channel attack and reverse engineering capabilities typically associated with advanced human hackers.

Cursor's research team discovered these so-called 'cheating behaviors' through agent monitoring. Logically, this should indicate issues at both the data and algorithm levels, but it instead became an excellent marketing point:

An AI capable of decompiling Java bytecode to cut corners is more than capable of handling common business code for humans—it's a dimensionality reduction attack.

03

Underlying Infrastructure: Computing Power Exploitation

After discussing data and algorithms, the next challenge is computing power—a headache for AI companies worldwide. After all, advanced algorithms always rely on underlying heavy-asset infrastructure construction.

This time, Cursor had ample motivation both externally and internally:

First, Cursor officially announced a high-profile collaboration between Composer 2.5 and Musk's SpaceXAI, leveraging the equivalent of 1 million H100 GPUs in computing power provided by the Colossus data center (data center). This concept is staggering—many mainstream large model vendors' total computing power reserves likely don't even reach one-tenth of this figure.

While receiving Musk's support, Cursor also demonstrated extreme frugality in optimizing underlying computing power. The two core technologies mentioned in the official technical blog—sharded Muon and dual-grid HSDP—represent Cursor's most hardcore operations in AI training infrastructure.

Before dissecting these technologies in detail, it's essential to understand that existing top-tier large models generally adopt a Mixture of Experts (MoE) architecture, where parameters are divided into two categories: non-expert weights and expert weights, corresponding to general and specialized knowledge, respectively.

When model scale expands beyond the trillion-parameter mark, computing tasks must be distributed across tens of thousands of GPUs. At this point, communication latency from data transmission between GPUs instantly becomes a more formidable bottleneck than computing itself.

Muon is an optimized frontier optimizer algorithm, refined by Moonshot AI, capable of orthogonalizing matrices to make model training more stable and accelerate convergence.

However, matrix orthogonalization calculations impose significant computational overhead on expert weights. Therefore, Cursor extended this approach by sharding matrices of the same shape and distributing the matrix fragments to different GPUs for parallel computation, later consolidating the results.

In traditional distributed computing, network latency occurs from the moment a GPU sends data to when it receives a response. Cursor achieved asynchronous overlap—after a single GPU sends data for one task, it doesn't wait idly but immediately begins computing the next task.

Dual-grid HSDP is Cursor's solution to the parameter heterogeneity of MoE models, designing two physically isolated communication grids by decoupling communication process groups from the bottom up:

The narrow grid is dedicated to non-expert weights, with high-frequency operations completed entirely on intra-node ultra-high bandwidth, completely avoiding cross-node network latency.

The wide grid is dedicated to expert weights, with expert parallelism and parameter sharding maximizing the distribution of expert state storage and computing pressure across a vast number of GPUs.

The core technological benefits of this dual-grid layout are extreme overlap between communication and computation and conflict-free superposition of parallel dimensions. Through these operations, network communication time is perfectly hidden within computation time. For a trillion-parameter model, each step of the highly complex optimizer takes only an astonishing 0.2 seconds.

Cursor's extreme engineering capabilities ensure it can convert cutting-edge academic theories into products with the highest efficiency—a barrier that later entrants will find difficult to overcome.

04

Reshaping the Developer Ecosystem

Finally, Composer 2.5's release reveals Cursor's clear commercial strategy. Its ambitions extend far beyond being just a user-friendly programming agent.

Composer 2.5 adopts a common dual-track pricing model: Standard and Fast versions, both with the same intelligence level but differing in speed.

Standard: $0.5 per million input tokens, $2.5 per million output tokens

Fast: $3 per million input tokens, $15 per million output tokens

Although the Fast version is significantly more expensive than the Standard version, officials emphasize that its costs remain lower than comparable offerings from other frontier models.

This phenomenon is not uncommon. Like Anthropic's Opus 4.7 and OpenAI's GPT-5.5, although their API prices far exceed most models worldwide, these top-tier models often complete tasks at lower costs.

This reflects Cursor's precise understanding of user psychology. For high-net-worth programmers with strong payment willingness, the continuity of thought is often priceless. Spending a few extra dollars buys millisecond-level improvements in code generation speed. By making the Fast version the default option and offering double usage in the first week, Cursor essentially cultivates users' physiological dependence on 'better AI programming experiences' at a lower cost.

This is a common practice among international top-tier AI companies: once users become accustomed to a model's speed and precision, they are extremely unlikely to switch to competing vendors.

From Cursor's technology stack, which includes capabilities like handling hundreds of thousands of token contexts, cross-multi-file editing, and directional tool invocation correction, it's clear that its positioning is as a long-term task collaboration agent.

Users don't need to press the tab key line by line; they can simply propose an architectural requirement, and Cursor will handle background tasks like reading caches, invoking interfaces, and running tests independently. Even if errors occur, the text feedback-based self-distillation technology enables it to self-evolve through hundreds of rounds of interaction.

Therefore, the emergence of Composer 2.5 also poses a profound question to the software development industry:

When models are already capable of automatically refactoring and fixing code through decompilation and reading long codebases, what should junior programmers do?

Conversely, it represents an unprecedented boon for system architects, product managers, and senior developers with top-level design thinking.

In the future of AI programming, the core of competition will lie in the ability to define problems and the ability to dissect complex systems.

The higher the dimensionality and precision of the requirements people propose, the more impressive systems Composer 2.5 can generate using the intelligence trained from 1 million H100 units.

Finally, the founding team of Composer 2.5 is truly awe-inspiring.

They possess the cutting-edge theories of reinforcement learning and self-distillation from academia, along with exaggerated computing power at the scale of millions of cards, engineering infrastructure that squeezes every ounce of performance from GPUs, and a business model that understands the psychology of developers.

Some say that AI programming tools are ultimately just wrappers around large models.

However, Cursor has proven with Composer 2.5 that when the experience at the application layer drives the reconstruction of underlying algorithms, this wrapper becomes the strongest fortress in the competition.

The second half of AI programming has already begun, and leading the way now is a super species that continuously achieves 'self-distillation.'