SaaSpocalypse

In February 2026, Wall Street saw $285 billion of tech-stock market value evaporate in a single 24-hour window. The trigger was Anthropic announcing Claude Cowork, an AI suite that the markets read as direct competition for the everyday tools companies pay billions to license. By the next morning, the trade-press had a name for it — the SaaSpocalypse — and the thesis was simple enough to print on a napkin: why pay for ten software seats when one AI agent handles the workflow.

I was not at a desk in Manhattan watching it. I was at my own desk in Medellín, quietly canceling another subscription that no longer earned its place.

This morning the renewal email arrived for the next one — JetBrains All Products Pack, about $200 a year, the toolset that has carried the entire interior of my engineering career — and I closed the loop on it. Cancellation, uninstall, the quiet aftermath. The same operation, repeated quietly, on a slightly bigger emotional target.

The version of the SaaSpocalypse happening at my desk has been running for a year. It runs ahead of the public-market thesis by months. It is more boring, and more total, than what any analyst can model from a Bloomberg terminal — because it is not about which enterprise vendor gets disrupted by which AI agent. It is about what stops being software at all when the operator turns into a developer.

The plain-language version

I used to pay companies for apps that solved specific problems: coding, finance tracking, journaling, planning, knowledge management. Now I keep the knowledge in markdown and let an AI agent maintain the system around it. The app does not wait for a product manager anymore. It changes when I tell it to change.

TL;DR for engineers

Chapter 1 — I canceled JetBrains today

The email came in this morning: my JetBrains All Products Pack renews in one month. Roughly $200 a year. Not a ridiculous price. Not for a professional tool. Not for something that has been with me for essentially my entire engineering life.

I have used JetBrains for as long as I can remember taking software seriously. IntelliJ. WebStorm. PyCharm. DataGrip. The whole cathedral. There are products you use because they are good, and products you use long enough that they become part of your nervous system. JetBrains was both.

So the cancellation felt stupidly emotional.

That is melodramatic, obviously. It is an IDE subscription, not a blood oath. But engineering careers accumulate inside tools. Keymaps become reflexes. Project panes become geography. The way a debugger opens, the way an import resolves, the way a refactor preview lists danger before touching code — those things become private muscle memory. JetBrains earned that attachment. It was serious software for serious developers. Heavy, yes. Sometimes too clever. Sometimes too much. But serious.

And then the cold realization landed: I simply do not need it anymore.

Not because JetBrains got bad. That would be an easier essay. It did not. JetBrains is still excellent at being an IDE. The problem is that my daily work no longer orbits an IDE.

I live in agent interfaces now.

Claude Code. Codex. Terminal sessions. UI sessions. The actual engineering motion happens through the AI. I describe the objective. The agent reads the codebase, edits files, runs tests, checks diffs, updates docs, commits when appropriate. I am not sitting inside an IDE manually navigating symbols for eight hours. I am operating one layer above that.

The processes, compilation, searches, runs, debugging loops, and implementation passes now happen inside the agent workflow. The IDE is not the command center anymore. It is a place I occasionally look at the terrain.

For that residual need, I use Zed.

Zed gives me the file tree, markdown preview, JSON and config inspection, quick diffs, occasional Git work, and a fast editor when I need to touch something directly. It is lightweight. It opens instantly. It is free. I have it dressed in the JetBrains dark theme with the JetBrains icon pack, because I am not above emotional continuity. The room still looks familiar. The machinery is gone. This is the practical sequel to Zed: The Convergence — that piece was about collapsing terminal, editor, and AI workflow into a sharper interface. Today was the next step: admitting that the convergence had already happened, and the old center of gravity was now decorative.

Worth noting the macro context underneath the personal moment. JetBrains itself ran into 2026 turbulence — the first individual-IDE price increase since 2017 came in late 2025 (10-18%), the new AI Pro and AI Ultimate licensing structure has been confusing enough that heavy users routinely top up another $40 a month in credits beyond their subscription, and developer-community sentiment has visibly shifted toward Cursor, Claude Code, and similar AI-first surfaces. I am not an outlier — I am part of a wave.

I canceled. Then I uninstalled the apps from my Mac.

No ceremony. No rage. No "goodbye old friend" nonsense.

Just a clean deletion and a strange little absence where a career habit used to be.

Chapter 2 — A year of cancellations

JetBrains is just today's example. The broader pattern has been running for a year.

I have canceled a lot of subscriptions.

The finance app went first. I used to need a finance management product because personal finance, like most life operations, pretends to be a dashboard problem. Accounts, categories, charts, budgets, alerts, historical views. You log in, click around, reconcile the little boxes, and hope the product's model of your life matches reality closely enough to be useful.

Now my finance system is a Claude project.

Markdown files. Financial snapshots. A few scripts where automation helps. The agent maintains the state in real time. I give it an update; it writes the dated snapshot, computes the delta from the previous snapshot, and tells me what changed. If I want a new view, I ask for it. If I want a new rule, I add it. If the structure stops fitting my life, the structure changes.

That is not a finance app in the old sense. There is no polished dashboard. There is no product roadmap. There is no settings page where I beg some anonymous team to support the exact thing I need. Just a living knowledge base and an agent that understands the conventions.

The same pattern spread everywhere.

Blog management. Diary. Journaling. Household admin. Personal planning. Health tracking. Each domain became a Claude project: markdown files, instructions, routing rules, scripts where needed, and an AI agent maintaining the system as I use it. I wrote about the life-management version in The Exomind — the important part was not "I have notes." Everyone has notes. The important part was that the notes became operational. I speak in normal language and the agent routes the knowledge, updates the right files, keeps timelines current, commits changes, and makes the system more useful over time.

The Cockpit described the infrastructure version: a private command center where the knowledge base, rules, scripts, and agents live together. The Knowledge Base That Builds Itself described the deeper pattern: the AI does not just read the knowledge base, it helps maintain it.

Then there was Google.

In You're Not Googling Anymore, I wrote about the moment the search reflex quietly disappeared. Not because I made a principled decision to boycott Google. I just stopped going there first. The behavior moved into AI chat. The ten blue links became a historical interface, like a phone book with better typography.

This is the same thing.

The spreadsheet app, the finance app, the journal app, the school tracker, the content calendar, the personal CRM, the bookmark manager, the habit tracker, the lightweight project management tool, the knowledge dashboard — one by one, they stop being destinations. Their useful parts get absorbed into an agentic workflow wrapped around files I own.

You do not notice the death at first. You just stop opening the app.

Then the renewal email arrives.

Chapter 3 — The SaaSpocalypse — what Wall Street saw

Three months before this morning's JetBrains email, the public markets had their own version of the same realization. February 2026: Anthropic announced Claude Cowork — an AI suite explicitly aimed at the everyday workflows enterprise SaaS used to monopolize. The 24-hour reaction was a $285 billion drop in tech-stock market value. Investors did not need an essay. They had a thesis: AI agents collapse the seat-license economy.

By March, the trade press had collected enough data to put numbers on it. A Retool report that ran in TechCrunch found that 35 percent of enterprise teams had already replaced at least one SaaS product with a custom-built AI-assisted alternative. 78 percent expected to build more such replacements before the year was out. Klarna had publicly ditched Salesforce's flagship CRM for a homegrown AI system. The term "vibe coding" — coined by Andrej Karpathy in early 2025 to describe building software by describing what you want in plain language and letting AI write the code — had gone from a niche phrase to a board-deck phrase to an industry-cliché phrase in twelve months.

The honest read is more interesting than "AI killed SaaS." Three things are happening at once.

First — the personal layer is falling fast. Power users, technical users, and operators with patience for markdown have already replaced a lot of consumer SaaS. The cancellation is real, the savings are real, the workflows are tighter. This article is one data point in that wave.

Second — the enterprise layer is starving, not dying. Salesforce, Workday, ServiceNow still own systems-of-record, compliance, multi-tenant data, integration sprawl. What's collapsing is the seat count. As Fortune put it bluntly: "AI isn't eating the product. It's eating the budget." If ten AI agents do the work of one hundred sales reps, you don't need one hundred Salesforce seats. Same product, fewer wallets pointed at it.

Third — there's a debt counter running. Industry observers have started calling 2026 the Year of Technical Debt, because the surge of AI-generated code that replaced SaaS in afternoon-projects is going to need extensive cleanup as bugs, security flaws, and scaling failures surface. The replacement layer is real, but it has its own version of the engineering tax.

All three are true. None of them changes the trajectory. The cancel button keeps getting clicked.

Chapter 4 — The user-developer collapse

The actual thesis is not "AI replaces JetBrains." That is too small, and mostly wrong. JetBrains is an IDE company. It will adapt or it will not. The more interesting thing is what happens to the boundary between user and developer.

Traditional software has a gap baked into it.

You, the user, want something. A field. A report. A workflow. A button. A different sort order. A weird edge case that only matters to your life. You file a feature request, or you work around it, or you churn. Somewhere else, a product manager decides whether enough users share your pain. Somewhere after that, developers implement it. Somewhere after that, the release ships. Maybe.

That gap is the entire premise of consumer SaaS.

The company owns the product. You rent access to the product. Your workflow has to bend toward the product's model of the world. The product improves on the company's timeline. Your job is to pay, adapt, and wait.

AI agents collapse that gap for a large class of software.

If the thing you need is mostly personal data, workflows, documents, reminders, analysis, reporting, transformations, light automation, and state over time, you can build the equivalent as a markdown knowledge base plus an agent. The data lives in files. The behavior lives in instructions and scripts. The interface is chat. The product evolves as you use it.

"I want a monthly finance report that compares wallet drift against expected burn."

That is not a feature request anymore. It is a message.

"When I mention an appointment, file the note and add a follow-up reminder."

Message.

"When I publish a blog post, update the marketing log, generate the social drafts, and cross-link related AI posts."

Message.

"Split this file because it passed 500 lines and the sections are now stable."

Message.

The distance between wanting the feature and having the feature shrinks to the width of the instruction, plus whatever verification the agent runs. That is the user-developer collapse. You are not merely consuming software. You are continuously developing your own operational layer while using it.

This does not mean every person becomes a programmer in the old sense. Most people will not write React components or migration scripts by hand. The point is stranger than that: the agent becomes the translation layer between intent and implementation. For engineers, the effect is immediate because we already understand structure, files, edge cases, and failure modes. We can supervise the agent. We can read the diff. We can smell a broken abstraction before it hardens.

But the direction is not limited to engineers.

First the technical users leave the generic apps. Then the power users. Then the users who are tired of waiting for SaaS roadmaps to notice their lives. Eventually the normal consumer gets a packaged version of the same capability: not "download this app," but "describe your workflow and let the agent maintain it."

And if you genuinely need a real application — UI, mobile, calendar integrations, charts, shared access, permissions — you can build that with AI too. Not always perfectly. Not always cheaply enough for production. Not without judgment. But enough to destroy the old assumption that the only alternative to buying a SaaS product is hiring a development team.

For many personal workflows, the better product is not an app.

It is a knowledge base that can change itself.

Chapter 5 — Who dies, who wins

The companies that die are the ones whose entire value proposition is "we gave your spreadsheet a login screen."

Consumer SaaS has been full of these products for fifteen years. Dashboards around personal data. Trackers around habits. Thin workflow wrappers. CRUD with nice onboarding. A notification system. Some charts. A mobile app. Maybe a Zapier integration. Maybe AI features bolted on now, because the board asked about it.

That is not enough anymore.

If your product can be recreated as markdown files, a few scripts, and an agent in an afternoon, your moat is already gone for technical users. If your AI strategy is "we added a chat panel to the existing dashboard," you have misunderstood the threat. The threat is not that ChatGPT will answer questions inside your product. The threat is that the user will stop opening your product.

The winners are different.

They will build for agent-native consumers. They will expose clean APIs, portable data, local-first exports, MCP servers, CLI surfaces, and composable primitives. They will assume users want to bring agents to their data, not trap data inside a dashboard. They will sell infrastructure, trust, network effects, regulated execution, collaboration, distribution, and hard integrations — the things an individual agent project does not trivially replace.

Some products still matter because they touch the outside world. Banking rails. Healthcare systems. Legal filing. Payroll. Insurance. Marketplaces. Social networks. Team coordination. Devices. Compliance. Shared truth. The agent can operate these systems, but it does not make them disappear.

The lazy middle is exposed.

Not because I want companies to fail. Because consumers have been forced to rent mediocre abstractions for too long. The friction is coming out of the system. Engineers win first because we can build our own replacements fastest. Everyone else follows when the pattern gets packaged.

The companies that thrive will use this moment to innovate. The ones complaining that AI is stealing their work are telling you they thought the work was protected by friction.

It was not.

Hot takes

1. The next wave of consumer SaaS churn will not look like rage. It will look like renewal emails for apps people forgot they stopped using.
2. "We added AI" is not a strategy if the user can add your entire product to their own AI workflow.
3. The moat was never your dashboard. It was the user's inability to build a better one in ten minutes.
4. Power users do not want more settings. They want software that can be rewritten mid-flight.
5. If your product's core object is a private knowledge base, your real competitor is a folder of markdown files and an agent with taste.
6. The $285-billion-in-24-hours market reaction was directionally right and chronologically late. The cancellations had been quietly happening for a year.

Closing

The next 12 to 24 months will be brutal for products that exist only because users used to lack implementation capacity.

That capacity is here now. Unevenly distributed, sometimes messy, often overclaimed, but real. A technical user with Claude Code, Codex, a markdown knowledge base, and a few disciplined rules can replace a surprising amount of personal SaaS. Not hypothetically. Operationally. I know because I keep canceling things.

JetBrains just happened to be the one that hurt.

The company-scale version of this is Sinapt and the Queryable Company. Personal workflows collapse into Claude projects. Company workflows collapse into an agent-first knowledge layer where the institutional context is queryable, portable, and alive. Same pattern. Bigger surface area. Higher stakes.

I did not cancel JetBrains because I stopped being an engineer.

I canceled because the engineering interface changed.