The Real Challenge for Cursor

Recently, there has been much discussion about Cursor and whether it will be overshadowed by emerging AI IDEs or new coding agent tools. However, I believe the real pressure on Cursor is not merely due to increased competition.

The true change is that model companies are starting to integrate coding agents directly into their subscription systems, product entry points, and workflows. OpenAI has incorporated Codex into ChatGPT’s subscription model, while Anthropic has integrated Claude Code into Claude’s unified subscription. At this point, the market competition is no longer just about which AI IDE is more user-friendly; it is about how model companies define why developers should pay.

This is the most significant aspect of the Cursor discussion. It reveals not just a product issue but a larger structural problem: when model companies start creating products themselves, can the AI application layer still maintain its value like traditional software companies?

From the Cursor case, the answer is at least not as optimistic as many might think.

Why Cursor is Worth Discussing

First, it’s essential to clarify that Cursor cannot be lightly categorized as a mere “shell” product. If you have used it seriously between 2023 and 2024, you would understand why it has gained traction. Its real strength lies not just in embedding large models into an IDE but in innovating around how programmers write code.

Its early competitive edge was its product completeness. Features like code completion, cross-file navigation, and context management were groundbreaking at the time, redefining many people’s expectations of AI programming tools.

Thus, Cursor deserves analysis not because it is weak but because it is strong. Its strength highlights that the current problem is not just about how well a team performs but that the AI application layer is facing structural pressure.

The Real Change is Not Just Increased Competition

The pressure on Cursor is not merely due to the emergence of more AI IDEs; it is that the focus of AI programming has shifted. Earlier, developers were more concerned with the accuracy of code completion, the smoothness of editing, and the intelligence of local rewrites. During that phase, understanding the editor and context management better allowed for a competitive advantage.

However, after 2025, developers increasingly want agents to handle longer, more complex tasks that span multiple files, tools, and steps. Once competition reaches this stage, many product-level differences will lose weight. UI, interaction, and engineering encapsulation remain important, but the factors determining the ceiling will increasingly return to the models themselves.

To put it bluntly, many of Cursor’s advantages from 2023 to 2024 came from better embedding AI into the IDE; after 2025, the market will increasingly compare whose model is better suited to complete real development tasks directly.

When model capabilities enter a stage where one strong model can outperform ten weaker ones, the hard-won differences made at the application layer will be quickly compressed.

Codex and Claude Code: Not Just Ordinary Competitors

If only a few more AI IDEs emerged, Cursor would still have ample operational space. However, what truly changes the game is OpenAI’s Codex and Anthropic’s Claude Code.

These offerings do not just introduce another tool similar to Cursor; they signify that model companies are directly defining developer workflows, occupying subscription relationships, tool entry points, and the workflows themselves.

Why is this important? It is no longer an abstract trend but a very concrete product arrangement. OpenAI now places Codex directly into ChatGPT’s multi-tier subscription system, while Anthropic has integrated Claude Code into Claude’s unified subscription.

In other words, coding agents are no longer just downstream applications of model APIs; they are being bundled directly into the main subscription products of model companies.

This means that Cursor faces not just “another product that is stronger than mine” but upstream companies that are creating their own products, turning coding agents into part of their subscription systems.

Especially with Claude Code, it reminds the market of one crucial point: what developers are truly willing to pay for may not be a specific IDE shell but whether the model can directly enter terminals, codebases, and workflows to get the job done.

The Real Fatal Issue: Asymmetrical Cost Structures

If Codex and Claude Code bring entry pressure, a deeper layer of pressure comes from cost structures. For the same $20 or $200, the offerings from model companies and Cursor are fundamentally different.

Cursor’s personal plans are Pro at $20/month, Pro+ at $60/month, and Ultra at $200/month. Its documentation clearly states that the usage of these plans is essentially calculated based on upstream model API rates.

This indicates that Cursor’s subscription capabilities struggle to establish independence from upstream model costs. For OpenAI and Anthropic, coding agents are no longer isolated tools but part of a larger model product system. They sell not just coding but also chat, research, document processing, desktop, mobile, and the models themselves.

Because of this, they can treat coding agents as customer acquisition tools, retention tools, or even as part of subscription subsidies. But Cursor is different; it remains an intermediary layer.

Even if it can secure decent procurement discounts, it is challenging for Cursor to subsidize upstream model capabilities with its own cost structure like the model manufacturers can. This is why the same $20 or $200 subscription from model vendors often comes with more aggressive usage, capability boundaries, and psychological expectations. Model companies sell their model capabilities and computational surplus, while Cursor sells capabilities procured from upstream.

The former can treat coding agents as part of their subscription systems for subsidies, while the latter must first consider whether it will incur losses.

This is not a pricing tactic issue but a value chain positioning issue.

Cursor is Not Sitting Idly

This article does not intend to suggest that Cursor has done nothing. On the contrary, Cursor is acutely aware of this problem and is striving to reclaim value for itself: on one hand, it continues to enhance its product capabilities, and on the other, it is attempting to train its own models.

This indicates that it is unwilling to merely be a passive intermediary distributor. However, therein lies the problem. The more it strives for this, the more it highlights that the core of this competition has returned to the model layer. If the application layer could maintain profits solely based on product experience, it would not have such a strong incentive to ascend to the model layer.

To this day, developers’ evaluations of AI programming tools remain heavily influenced by the performance of top models. Discussions revolve around whether Claude, OpenAI, or Gemini are effective, rather than just how well a shell performs.

This itself indicates that the value center has not genuinely shifted to the application layer.

Cursor’s Issues Are Not Just Cursor’s Issues

Thus, the real danger for Cursor is not whether it will be defeated by a new AI IDE. The genuine threat arises when model companies possess both the underlying capabilities and begin directly creating products, packaging subscriptions, and occupying entry points. The application layer in between will increasingly struggle to justify why it should retain a portion of the profits long-term.

The demand is undoubtedly real and may continue to grow. AI programming will not disappear, and agents will only deepen their integration into development processes. However, real demand does not equate to value necessarily belonging to the application layer.

The reason traditional software companies could consistently secure profits was that the upstream capabilities were relatively stable, allowing product companies to gradually build their moats around workflows, collaborative relationships, organizational embedding, data accumulation, and distribution channels.

But AI applications face an upstream that is rapidly evolving and integrating upward. Model capabilities are quickly overflowing, cost structures are controlled by others, and even the product entry points may be directly taken by model companies.

If this issue remains unresolved, today it is Cursor, and tomorrow it could be more AI application companies. This is why I believe Cursor is a topic worth discussing. It may not lose immediately, and it certainly has value, but it exposes a larger reality: in the AI era, many application companies will find that they no longer inherently possess that value.

They may still rely on workflow embedding, team collaboration, and specific scenarios to create new moats, but this layer of value no longer defaults to belonging to the application layer. At least from the Cursor case, model companies are gradually reclaiming the value that might have been retained at the application layer. If we continue along this line, many discussions today framed as “individual product victories” may need to be reinterpreted.