The Merging Take Is Too Early

Everyone is calling for AI coding tools to merge. This week alone I've seen three takes saying the space is consolidating, the winners are picking themselves, time to pick a side.

I think this is reading the cycle wrong.

We are not in the merging phase. We are in the explosion phase. Hundreds of tools are going to emerge and die before any real merging happens. Calling for consolidation right now is like standing in the middle of the Cambrian explosion telling everyone to pick a vertebrate.

The actual thing happening right now — if you watch closely — is not merging. It's copying. Every tool is trying to do everything. The IDE plugin is adding agents. The agent is adding an IDE. The chat tool is adding a terminal. The terminal tool is adding a chat. Nobody is merging with anyone. They're all sprinting toward the same imaginary all-in-one product because that's what the funding decks told them to build.

This is what the noise looks like before a shakeout. Not before a consolidation.

What Merging Actually Requires

Merging requires a few things to be true that are not yet true.

The surface area of the problem needs to be stable. Right now it's changing every quarter. Last year, coding tools were autocomplete plus chat. This year they're autonomous agents that file PRs. Next year it will be something else. You cannot consolidate around a moving target.

The winners need to be clear enough that buying is cheaper than building. Nobody is in that position. Cursor is not buying Continue. Claude Code is not buying Aider. Windsurf is not buying anyone. They're all still in the land grab.

Distribution needs to matter more than capability. We're still in the phase where capability matters more, because the tools are genuinely different from each other in what they can actually do. Once they all converge on the same capability ceiling, distribution starts to matter — and then you see acquisitions. We are not there.

What Is Actually Happening

What's actually happening is the part of the cycle nobody likes to write about, because it's messy and there's no clean narrative.

Tools are copying each other. Features are getting cloned within weeks. Differentiation is collapsing on the obvious axes — autocomplete quality, chat quality, agent capability — and shifting to the non-obvious ones: latency, cost per task, long-context handling, integration with what you already use.

Most of these tools are going to die. Not because they're bad, but because they were built for a window that closed. They raised on the assumption that "AI coding" was the category and they just had to claim a slice of it. They didn't notice that the category is fragmenting faster than they can ship.

The survivors will be the ones that pick a real wedge and go deep instead of trying to be a platform. The wedges that win are the ones an all-in-one tool won't bother with, but that you can't work without once you've used them.

Why This Matters If You're Building or Buying

If you're building: Don't try to be a platform yet. The platforms haven't been built. The picks-and-shovels layer hasn't been built. There is far more room in doing one specific job better than anything else than in being the next Cursor.

If you're buying: Don't commit to a stack expecting it to be your stack in 18 months. It won't be. The tool you're using today will probably be acquired, killed, or pivoted before you finish onboarding your team. Build your workflow around the assumption that the tools will change and the API contracts will not.

The Merging Comes After the Shakeout

The consolidation will happen. But it happens after the shakeout, not before. When most of these tools are dead and the surviving three or four have stopped sprinting toward feature parity and started looking for ways to grow without spending more on capability they can't differentiate — that's when you'll see acquisitions.

Calling for merging right now is just rebranding the noise. The noise is the explosion. The merging comes after the shakeout, and we haven't had the shakeout yet.

---

I'm building one of these tools. Prism is an API proxy that does routing and session memory, nothing else. That's the bet — that the wedge is more useful than the platform, at least for now. Get an API key or read the docs.