The Truth Behind JetBrains' First-Ever Loss: AI Is Dismantling Software's Profit Machine

JetBrains, the 16-year-old developer tools giant, just filed its first annual loss. Nearly everyone's immediate reaction was: it got crushed by Cursor, burned by AI. But reading through all 45 pages of the audit report reveals that the direct cause of the loss isn't AI at all — the truly dangerous number is hiding in a different line entirely.

Let's Get the Facts Straight: The Loss Came from FX, Not Core Business

In fiscal year 2025, JetBrains' operating profit was positive — 751 million Czech koruna. In other words, the core business didn't lose money at all.

The loss came from a 1.516 billion koruna foreign exchange loss. JetBrains sells software globally but spends money in the Czech Republic, with overseas revenue accounting for 65.9% of the total. When the koruna appreciates, a layer of that overseas income gets wiped out by exchange rates — resulting in a pre-tax loss of 325 million koruna.

So technically, what caused JetBrains' first-ever loss was currency fluctuation, not AI stealing its lunch. But that's just a surface-level explanation. What should truly set off alarm bells is a quieter curve buried deeper in the financials.

The Real Danger: Revenue Is Growing, Profit Has Been Halved — Twice

Revenue is still growing, up 6.3%. But operating profit evaporated 63.2% in a single year, with the margin dropping from 13.55% straight down to 4.69%.

Revenue rising while profit collapses — that's the question that demands an explanation. When a software company's revenue curve looks healthy but its profit curve craters, it means the cost structure is undergoing a fundamental shift. And this isn't unique to JetBrains — it's something the entire software industry is going through.

The Two Legs Software Has Always Stood On — One Is Already Broken

For the past two decades, the software industry extracted outsized profits by standing on two legs.

First leg: Marginal cost approaching zero. Selling one more license costs almost nothing extra — that's software's biggest advantage over manufacturing. But this leg is broken in the AI era. Every AI call comes with a real invoice, compressing gross margins from 80–90% down to 45–53%.

Second leg: Per-seat pricing. The more people a customer hires, the more software seats get sold, and the company grows along with it. This leg is still standing for now, but it's under pressure — there's no direct evidence in the financials of it breaking yet.

The reason marginal-cost-approaching-zero logic fails in the AI era comes down to the nature of AI inference compute. Traditional software, once developed, can be copied at essentially zero cost. But every call to a large language model drives billions of parameters through a complete forward pass, consuming real GPU compute, power, and memory bandwidth. That resource consumption scales linearly with request volume — it doesn't get diluted as the user base grows. The per-token pricing from OpenAI, Anthropic, and others is a direct reflection of this physical reality. For every company building AI applications on top of these models, API call costs are a bill that scales proportionally with usage — fundamentally breaking the software industry's core logic of "the more you sell, the lower your unit cost."

The Myth of "Declining Seats": The Financials Don't Support It

A narrative has been circulating that Atlassian saw its first-ever seat decline, presented as ironclad proof that the SaaS per-seat model is collapsing.

Checking the actual financial reports, this claim doesn't hold up. Atlassian's subscription ARR grew 23%, RPO grew 44%, and there was zero disclosure about declining seats. Figma reported seat expansion with a 136% net retention rate. Adobe posted record revenue with AI-related ARR up 150%. Not a single company has reported seat declines in their financials.

In other words, the "software is doomed" narrative is driven more by market sentiment than by financial fact.

Valuations Crashed, But Revenue Is Still Growing

In February 2026, software stocks lost roughly $1.2 trillion in market cap within 48 hours — a real valuation collapse.

But Stripe built an index using 72,000 SaaS companies on its platform, and over the same period those companies' revenue growth actually accelerated past 30%. The market has already issued a death sentence for software, but the autopsy report isn't in yet. Valuation panic and fundamental reality are currently showing a stark divergence.

The Pressure Is Real, but It Hits Different Companies at Different Times

The pressure is real — it just reaches different companies at different speeds. China's two ERP giants illustrate two starkly contrasting fates.

One spent five years in the red, clawed its way back through a subscription model transition, and got cloud revenue to 86% of the total. The other accumulated over 5.3 billion yuan in losses over three and a half years, trapped in a "person-days model" — the more people, the more complex the projects, the higher the costs.

This reveals a critical insight: AI doesn't punish traditional software per se — it punishes business models where revenue grows with headcount and costs grow with headcount too. When revenue and cost are both tied to the same variable, scaling up doesn't translate into profit expansion.

The Truth About AI Product Margins: Don't Short Yourself

For every team building AI products, there's a set of numbers worth writing on the wall:

• Traditional SaaS gross margin: 80–90%
• AI product gross margin: only 45–53%
• Cursor (including free users): gross margin of negative 31%

The core trap is a mismatch between pricing and cost: pricing is flat-rate monthly subscriptions, but costs are billed per token. This means the more active a user is, the more money you lose — you're essentially shorting your own gross margin.

But this same cost structure is actually a tailwind for independent developers. Even at 50% gross margin, large companies can burn through 40% just on sales expenses. Independent developers have no sales team, no channel commissions — 50% gross margin is 50% in their pocket. For the first time, small teams have a genuine cost structure advantage over large companies.

The mismatch between token-based costs and subscription pricing is fundamentally a hedge between a concave cost structure and a convex revenue promise. Subscriptions make an implicit promise of "use as much as you want," while costs grow monotonically with usage. When the average usage of active users exceeds the threshold assumed in pricing, each additional high-frequency user deepens the loss. Cursor's negative 31% gross margin is exactly this mismatch playing out on an extremely active user base. There are typically three paths forward: introduce usage caps or tiered pricing to transfer cost risk to high-frequency users; reduce model call frequency through caching, distillation, or smaller local models; or wait for inference costs to fall via Moore's Law and engineering optimization, restoring positive margins at current pricing. Most companies are exploring all three simultaneously.

How to Tell If You'll Get Eaten: Selling Features vs. Selling Position

History offers a case study with a 56x difference in outcomes that's worth using as a benchmark.

Borland sold "features" — and features eventually got bundled into platforms for free. The company sold for just $75 million. Netscape sold "position" — it occupied the distribution entry point, and even in defeat was worth $4.2 billion.

The conclusion is clear: features get standardized and commoditized; positions don't.

So JetBrains' real competitor isn't Cursor — it's the fact that the act of "writing code" itself is being devalued. When an industry's value shifts from "helping people do work" to "replacing people doing work," the moats that once made kings are built on a riverbed that's drying up.

The divergent fates of Borland and Netscape map directly onto the strategic distinction between "feature moats" and "network effect/distribution moats." Feature moats depend on technical leadership, but technical leadership can be caught up to and copied — once a platform bundles equivalent functionality (like Microsoft folding debuggers and code completion into Visual Studio), the standalone tool's value drops to zero. Distribution moats depend on user habits, data accumulation, and ecosystem lock-in: the more data users generate, the higher the switching cost; the more developers on the platform, the more users it attracts, creating a self-reinforcing flywheel. As AI reshapes the developer toolchain today, this framework remains entirely valid — what really matters isn't how good any particular AI code completion feature is, but who controls the entry point to codebase data and who defines where a developer's workflow begins.

The Cheaper the Tools, the More Valuable the Judgment

What this financial report is really about isn't the fortunes of JetBrains alone — it's about how AI is dismantling the most profitable machine in software: the marginal-cost-approaching-zero dividend is disappearing, token-based billing is reshaping gross margins, and the per-seat pricing model faces a fundamental revaluation.

For practitioners, the takeaway isn't pessimistic. As tools get cheaper and more standardized, what becomes scarce shifts from "can you build it" to "do you know what to build." The cheaper the tools get, the more valuable judgment becomes.