Cursor’s fate hangs between two speeds: the maturity of AI autonomous coding and Cursor’s own transformation.

Cursor continues to thrive, yet it is also heading towards despair. Opinions about this once iconic Vibe Coding company are sharply divided, yet seemingly valid at the same time.

As of February 2026, Cursor’s annualized revenue surpassed $2 billion, doubling from $1 billion just three months prior. No startup in Silicon Valley has crossed the $0 to $2 billion mark at such a pace before. Each day, 150 million lines of enterprise code are generated through Cursor, with over two-thirds of the Fortune 500 companies utilizing it. A new round of financing is underway, targeting a valuation of $50 billion. Martin Casado, a board member and partner at A16z, famously stated, “Without the capital invested, Cursor is the fastest-growing company we’ve ever seen.”

However, on a day in February 2026, a mortgage startup named Valon announced that over 90 employees would stop using Cursor in favor of Anthropic’s Claude Code. Valon’s CEO Andrew Wang claimed that Claude Code completed the same tasks ten times faster.

This incident, though minor—a tool migration decision from a small company—sparked a significant discourse on Twitter, with “Cursor is dead” becoming a trending topic in the developer community.

Casado’s response was widely quoted: “I’ve been a heavy internet user and a VC for ten years, but I’ve never seen a disconnect between X and reality like this—never in the past year. Cursor’s data shows no signs of failure.”

While he spoke the truth, a more complex question arises: when a company’s data is overwhelmingly positive, but a sensitive group within its industry begins to express collective unease, should one trust the data or the intuition?

Trusting Data vs. Intuition

Let’s first examine what the data does not reveal.

Claude Code was publicly released in May 2025, and by early 2026, its annualized revenue had already exceeded $2.5 billion, surpassing Cursor in absolute terms. Anthropic is also Cursor’s most important model supplier—Cursor’s products heavily depend on the Claude model, with Anysphere being one of Anthropic’s largest clients.

On another front, OpenAI acquired Windsurf for $3 billion—Cursor’s most direct competitor. Reports indicated that OpenAI had previously attempted to acquire Cursor itself, but negotiations fell through.

OpenAI subsequently launched Codex agent, a cloud-based asynchronous coding agent, which saw over 1 million downloads in its first week. Coupled with Microsoft-owned GitHub Copilot’s monopolistic distribution, Cursor is being squeezed from three directions.

Yet the most lethal force among these three does not come from any specific competitor. Zach Lloyd, CEO of Warp, succinctly captured Cursor’s true situation: “I don’t believe the meme ‘Cursor is dead,’ but ‘IDE is dead’ is real. Software is no longer done this way.”

This statement elevates the issue from “which product is better” to a completely different level: what is the ultimate form of AI coding? Is it a smarter editor, or is it a process that fundamentally eliminates the need for an editor?

If the future of software development involves humans describing intentions in natural language while AI autonomously handles everything from planning to implementation to testing, then IDEs—no matter how intelligent—may become an unnecessary intermediary.

Both Optimism and Pessimism are Valid

Casado claims there are no issues with the data, while developers express that something has changed. Neither is lying, but they are not discussing the same reality.

Understanding this requires a premise: a company’s situation is not a singular state but rather an amalgamation of multiple layers moving at different speeds.

The fastest layer is market narrative—shifts in Twitter sentiment, media tone, and valuation fluctuations change daily or weekly.

The middle layer encompasses product and business models—user growth, revenue structure, enterprise procurement, which change monthly or quarterly.

The slowest layer is the technological paradigm—what technology is considered the default option, how developers’ work methods are redefined, which changes occur over years.

Casado focuses on the middle layer. Doubling revenue, increasing enterprise contracts, and renewing Fortune 500 clients—Cursor is indeed in a state of overall success by these metrics.

The anxiety expressed by developers on X captures the shifts in the slowest layer: the technological paradigm of AI coding is transitioning from “assisting humans in writing code” to “AI autonomously writing code.” This shift has not yet reflected in revenue numbers, but it has left clear traces in other data.

SemiAnalysis estimated in February 2026 that 4% of public commits on GitHub were already completed by Claude Code—an application that had been released for less than a year. At its current growth rate, this percentage could exceed 20% by the end of 2026.

In the same month, a survey by Pragmatic Engineer revealed that 46% of developers listed Claude Code as their “favorite” AI coding tool, with Cursor in second place at 19%.

Claude Code has surpassed both GitHub Copilot and Cursor in usage within eight months of its inception.

These data points point to a singular fact: a shift is already occurring, though it has yet to be reflected in Cursor’s revenue reports.

Cursor’s revenue structure has a buffer layer. Enterprise clients currently account for about 60% of Cursor’s revenue. Individual developers and small startups are quietly migrating to Claude Code, but this attrition is temporarily masked by the growth of enterprise contracts.

Growth of Enterprise Contracts Masks Loss of Smaller Users

There exists a cognitive lag between these two groups. Individual developers have low switching costs and short decision chains—one person, one credit card, and an afternoon can switch tools. Enterprise clients, on the other hand, face lengthy contract cycles, security reviews, procurement approvals, and team training, making transitions less straightforward.

However, the key is that enterprises ultimately follow the developers. Enterprises do not choose coding tools; developers do; the IT department merely ratifies the decisions already made by engineers.

If the developers who propelled Cursor’s rise from 2024 to 2025 have transitioned elsewhere by the end of 2026, the enterprise procurement pipeline will inevitably dry up—not immediately, but eventually.

Casado’s judgment and developers’ intuition are not contradictory. Casado sees that the lower layers of the structure remain stable, while developers sense that the upper layers are beginning to shake.

Both perspectives are true.

Individual developers are the canaries in this structure—when canaries begin to leave, it does not mean the mine will collapse immediately, but it does mean serious air quality checks are warranted.

How Did Cursor Take Off?

But why are the canaries leaving at this moment? To answer this question, we must look not only at competitive comparisons but also at how Cursor reached its current height—and what changes are affecting the forces that lifted it.

Cursor’s rise is not the result of linear growth. It has experienced a rare phenomenon—multiple layers aligning simultaneously to create a lifting force.

A company is embedded in different layers moving at varying speeds at any given time: narrative and valuation change the fastest, product and business models are in the middle, while technological paradigms and industry structures change the slowest.

Narrative and valuation change the fastest, product and business models are in the middle, technological paradigms and industry structures change the slowest.

Typically, these layers move at different speeds and directions, with collaboration and conflict between them; this tension is the norm in the business world.

However, occasionally, the fast and slow layers point in the same direction, and companies standing at the intersection experience a weightlessness-like acceleration—obstacles seem to vanish, and the entire world opens up to them.

Between 2023 and 2025, at least two slow layers moved simultaneously: the coding capabilities of large language models crossed a practical threshold, and AI coding transformed from a novelty to a productivity tool; software development processes began to be reshaped by AI, making “AI coding tools” a necessity rather than an option.

The movements of these two slow layers pointed directly to Cursor’s position—an application that made AI the backbone of the editor rather than a plugin. Thus, buoyed by the currents of technological paradigms and industry structures, Cursor took off.

When taking off, no one thought about landing, but the currents will eventually stop. How high one can fly is not the key; what matters is whether, when you can take off, you have embedded yourself deeply enough in the layers. After the currents stop, will your technology become the standard? Will user habits be tied to you? These are the more pressing questions.

NVIDIA is a positive case: having also taken off on the currents of AI, it embedded CUDA into the very roots of the deep learning ecosystem. Even as narratives cool and valuations retract, CUDA’s position remains unshakable.

What about Cursor? What did it achieve during its takeoff window?

A $50 billion valuation is a product of the narrative layer. But Cursor is certainly more than just narrative. Tab completion, multi-file refactoring, inline editing—these features’ reputations were not built through financing pitches but through developers writing code line by line.

However, at the slower layers—industry structure and technological paradigm—Cursor’s embedding is shallow. It has not become the infrastructure standard in the AI coding field. Until the end of 2025, it remains a fully application-layer product reliant on third-party models.

According to Tom Dotan from Newcomer, Cursor spends nearly all its revenue on purchasing APIs from Anthropic. Revenue has quadrupled since then, but this structure has not fundamentally improved—each user interaction consumes model inference, and revenue growth and API costs have expanded almost in sync. One Cursor investor remarked, “Making 90 cents on a dollar is not a business.” The higher Cursor flies, the faster it bleeds.

This may not be fatal during the takeoff phase—when all layers are buoying you, you can first achieve scale before addressing profitability. But Cursor now faces a situation where the currents supporting its takeoff are changing direction.

From Assisted Coding to Autonomous Coding

Typically, the end of takeoff means the lifting force dissipates—the currents weaken, and the company descends. However, Cursor is not facing a weakening of currents—the overall direction of AI coding remains strong—but rather a shift in the direction of those currents.

The first phase transition is from “manual coding” to “AI-assisted coding.” This transition points toward IDEs—developers remain the drivers, AI is the co-pilot, and their collaborative interface is the editor. Cursor was born for this phase transition, perfectly capturing it.

The second phase transition is from “AI-assisted coding” to “AI autonomous coding.” This transition no longer points toward IDEs but rather toward terminal agents and cloud-based asynchronous workflows. Developers shift from being drivers to commanders—they no longer review code line by line but describe intentions and review results.

Claude Code is a product of this phase transition: it does not run within an editor; it operates in the terminal; it does not assist you in writing code; it writes code for you.

One could understand the first phase transition as Iron Man putting on his armor, with the human inside and AI as the equipment; the second phase transition is Jarvis putting on the armor for Iron Man, with the human outside giving commands—leading to the emergence of a more powerful Ultron.

Cursor is still flying, but the currents beneath it no longer point to its position. Revenue continues to double—because the inertia of the first phase transition persists, and enterprise procurement has not yet switched. However, the direction of the currents has changed. This is what developers feel on X and what Casado’s data temporarily fails to capture.

However, the change in the direction of the currents and the arrival of the currents at their destination are two different matters. The maturity of the second phase transition—AI autonomous coding—may be overestimated by its most enthusiastic supporters.

The 4% commit figure from SemiAnalysis sounds shocking, but a follow-up analysis revealed critical details: approximately 90% of commits by Claude Code on GitHub fall within repositories with fewer than two stars—mostly personal experimental projects rather than production code.

This figure’s value needs to be discounted: Claude Code’s usage is currently concentrated in new projects and personal experiments, not yet widely penetrating enterprise-level production codebases.

More sobering evidence comes from a randomized controlled trial by METR in 2025: experienced open-source developers using AI tools on large, mature codebases believed their efficiency improved by 20-24%, but actual measurements showed a decline of 19%.

The time saved by AI in coding was completely offset by the time spent on prompts, waiting, and reviewing outputs. Model capabilities have since significantly improved, but the core contradiction—that AI autonomous coding’s reliability on mature, complex codebases is far inferior to that on new projects—likely still holds.

The intermediate state of human-machine collaboration may be more enduring than many anticipate. The second phase transition is indeed occurring, but its completion timeline may not be months, but rather years.

This presents both good and bad news for Cursor: the window for transformation may be wider than the most pessimistic predictions; however, even if the window is wider, change will inevitably occur.

The Bet of Cursor

Cursor is not sitting idle. It is undertaking one of the most aggressive actions in its history: training its own model.

In March 2026, Cursor released the technical report for Composer 2. This is a large language model based on the MoE architecture, built upon the open-source model Kimi K2.5 from the dark side of the moon—boasting 1.04 trillion parameters and 32 billion active parameters.

Cursor has conducted extensive continuous pre-training and reinforcement learning on this foundation, expanding the training computation compared to the base model by four times.

Cursor initially did not disclose the identity of the base model; a developer discovered the model ID containing “kimi-k2p5” through intercepted API requests, sparking a controversy over transparency.

This incident itself reflects Cursor’s current situation: a nearly $30 billion US startup has chosen a Chinese open-source model as the foundation for its flagship product—illustrating the competitive edge of Chinese open-source models in terms of cost-effectiveness while exposing Cursor’s starting point in autonomous model capabilities.

However, the real interest lies not in the base model but in what Cursor is building on top of it: large-scale reinforcement learning based on real user behavior.

Cursor collects vast amounts of data from users’ interactions with the current model—when developers accept AI suggestions, when they reject them, and when they modify them—refining this into reward signals, updating model weights through a fully asynchronous RL pipeline, and deploying them back into the production environment.

The entire training infrastructure includes asynchronous pipelines across multiple regions and an internal computing platform named Anyrun, capable of running hundreds of thousands of sandboxed coding environments.

Cursor possesses unique assets that neither Anthropic nor OpenAI have.

Cursor has access to real coding behavior data from 150 million lines of enterprise code daily. No other company in the AI coding field utilizes such a scale of real production environment data for model iteration—Anthropic and OpenAI train general models with vast amounts of text and code data, but they lack the real-time behavioral flow of developers accepting or rejecting AI suggestions line by line. This is Cursor’s unique signal source and the reason for Composer’s existence.

Composer 2 achieved an accuracy rate of 61.3% on Cursor’s internal benchmark, CursorBench-3, a 37% improvement over the previous version. Fortune reports that Composer has surpassed Anthropic’s Opus 4.6 on certain benchmarks.

If Composer can handle most of the inference traffic, Cursor will no longer need to allocate all its revenue to Anthropic, potentially flipping its gross margin from negative to positive; simultaneously transforming from an application-layer company that can be easily replaced by upstream providers into a company with its own intelligent platform. Developing its own model is not just a product strategy but a matter of survival.

Parallel to Composer is a model-agnostic orchestration layer. Cursor’s management bets that enterprise clients will prefer products that do not tie them to a single model—given the rapidly changing landscape of AI models, no enterprise wishes to lock themselves into a single vendor’s ecosystem. Cursor’s president, Oskar Schulz, emphasizes, “95% of Cursor users are already agent users,” and the company is transitioning from an IDE to an agent scheduling platform.

The validity of this logic hinges on a genuine competitive equilibrium among underlying models. If a particular model vendor continues to lead in coding capabilities to the extent that other models become meaningless alternatives, “model neutrality” shifts from an advantage to a burden.

However, current evidence points to another possibility: in Fortune’s report, six developers and founders unanimously described a working style that involves using multiple tool combinations in parallel. Boris Cherny, the creator of Claude Code, himself admitted, “I don’t think it’s a winner-takes-all scenario.” If the market indeed moves towards a multi-winner landscape, Cursor as an orchestration layer has room to survive.

If the market moves towards a multi-winner landscape, Cursor has room to survive.

The third path is to align with the new direction of the currents. Cursor has launched Cloud Agent—a cloud-based coding intelligence that supports multiple parallel workers. Schulz emphasizes that the company is “disrupting itself time and again.” The essence of these actions is to acknowledge: the future of coding may indeed not lie within IDEs.

These three paths—developing its own model, model-agnostic orchestration, and cloud-based agents—constitute the complete picture of Cursor’s response. However, each path faces its own constraints.

Cursor currently has about 20 AI researchers working on model training, and Fortune recently confirmed that key engineers have left for Musk’s xAI. Anthropic’s research team is dozens of times larger than Cursor’s.

Even if the data flywheel can produce extreme optimizations in coding scenarios, the general intelligence ceiling of the base model ultimately depends on parameter scale, computational investment, and research depth—factors that a 400-person company cannot win in an arms race.

The more fundamental issue is that the data flywheel is built on an assumption: users will stay. If individual developers’ migration continues to accelerate, the data supply for the flywheel itself will shrink.

Cursor’s fate hangs between two speeds: the maturity of AI autonomous coding and Cursor’s own transformation speed.

If the intermediate state lasts long enough, Cursor will have time to complete the leap from an application-layer company to a model + platform company—valuation may retract, but core capabilities persist. If the speed of the current’s directional change exceeds the speed of transformation, the gap between a $50 billion valuation and negative gross margins will result in a hard landing. And a $50 billion scale means that acquisition is nearly impossible as a fallback.

Michael Truell has a photo of biographer Robert Caro hanging on his desk. He says he admires “those who have done useful and impactful work, and that work took a long time.”

But he runs a company in the AI era—in this era, slowing down for a week could leave you behind. The power to decide how software is created once belonged entirely to programmers, briefly shifted to tool companies that assist programmers over the past three years, and is now being reclaimed by those who control model capabilities.

Cursor’s real issue is not whether its product is good enough, but whether an application-layer company can maintain its position amid this redistribution of power—and whether it has enough time to answer that question.