For years infrastructure startups have optimized for ease of developer adoption, launching OSS frameworks, libraries, and databases as the on ramp to paid services. Whoever had the best developer experience could earn the right to own their part of the stack and become the “first default” of choice for new applications.
Today, open any modern editor: you type a prompt, hit ⌘-Enter, and an AI agent fills out the boilerplate. GitHub data shows developers now accept roughly 30% of Copilot’s suggestions on average, with acceptance rates rising as they trust the tool (GitHub). 73% of open-source contributors say they already use AI assistants in daily work (GitHub).
If a machine is writing a third of the code, who’s choosing the stack now?
“The last framework”?
Take frameworks as one example of a popular developer onramp. Models know what they’ve seen, and React is ubiquitous in public repos and models alike. Enterprise risk teams have already blessed it, which means green-light deployments with no additional security review. The result is a self-reinforcing loop: more AI-generated React today → more React in tomorrow’s model snapshots.
It seems reasonable to argue that established frameworks will maintain a stranglehold on applications—it will be infinitely harder for new frameworks to achieve the same level of presence in training data. But in an agent-oriented world, are frameworks even the right entry point?
Once an LLM is writing every commit, the traditional craft-focused notion of developer experience (DX) gives way to agent experience (AX)—how quickly a model can locate state, predict effects, and issue safe edits. For an agent, React vs. Vue isn’t a philosophical choice; it’s just a set of token patterns.
Agent-readable systems will trump human niceties in the next wave of tooling. Legacy frameworks stay popular today because they dominate training data, but their “semantic elegance” is irrelevant to a model. What agents value is whatever lowers the error rate.
That shift in priority opens a vacuum: if agents don’t care which framework they emit, someone still has to pick the default—and today that “someone” is no longer the individual developer.
It’s the IDE (and its embedded agent) that decides the stack.
IDEs as silent gatekeepers
Cursor has recently raised $900M at a $9 billion valuation barely four months after closing a $100 million Series B (TechCrunch). While investors have clearly been blown away by the company’s incredible ramp to a rumored $300M run rate, perhaps the more compelling opportunity still lies ahead—IDEs can own the developer workflow end-to-end.
Why? Because the editor has a high degree of control over its outputs. If Cursor discovers that its own “Cursor.js” preset passes tests 30% more reliably than vanilla React, it will steer one-click scaffolds toward that preset. Users may never notice.
Beyond frameworks, databases like Convex and hosting providers like Vercel are fighting for priority routing from IDEs and vibe coding tools alike, while also creating their own (Chef, v0). Supabase is probably the best known example of a preferred provider that has garnered a tremendous uptick in downloads in the past six months (X). It doesn’t feel like a stretch to imagine paid placement as yet another revenue stream for whichever platforms are able to capture and own the developer relationship at the top of the stack.
On top of distribution, IDEs also own the full stream of data collected from interactions between developers, models, and the editor. Model companies have been spending millions of dollars to acquire lower quality coding data from third party providers in a quest for continuous improvement; meanwhile, the best form of this data already exists natively within the IDEs. If anyone is well-positioned to automate the developer workflow, it’s the platforms that own the developer workflow.
In short, control of the editor window is becoming the new distribution choke-point for frameworks, runtimes, and even back-end services—and the interaction data that emerges as developers and agents make use of them. While Cursor and Windsurf might look like simple forks of VSCode, the audience they’ve attracted is far more valuable.
Here come the models
OpenAI seems to agree: the model provider is in talks to acquire Windsurf (formerly Codeium) for about $3 billion—its largest acquisition to date (Reuters). Controlling an IDE front-end will let a model vendor compile data from every keystroke, not just every API call.
In even more recent news, OpenAI just launched an agentic coding application of its own, Codex, followed swiftly by Google’s Jules. Both are fast following in Anthropic’s footsteps with Claude Code—model players across the board are clearly attempting to re-assert control over the end-user relationship before the IDE layer turns them into hidden, swappable backends.
Cursor proved there is real demand for an agent that lives inside the editor, but its success also highlighted a risk: if developers spend all day in Cursor, the Cursor brand—not OpenAI’s, not Anthropic’s—owns the workflow data, the customer touch-point, and the pricing power.
Why do these new combinations of model + UI tilt the field toward the model companies?
A richer data flywheel. With the interface in-house, a vendor can train on full “keystroke → diff → test → fix” traces, producing faster reinforcement loops than an IDE that sees only partial logs. Better feedback begets a better model, which in turn locks users more tightly to the vendor’s own interface.
Form-factor optimization. Because Anthropic and OpenAI design both ends of the contract, they can dictate prompt grammar, enforce code-shape rules (explicit state objects, deterministic functions), and even nudge users toward context-heavy operations that consume more tokens (X).
Pricing power. A model vendor can give its UI away and monetize purely on usage, whereas a stand-alone IDE must pay for tokens and then sell seats at a markup.
Default-stack control. The first-party editor decides which framework, database, or hosting preset appears when a user types “create.” That steerage is valuable real estate, whether platforms choose to direct traffic to a preferred partner or ultimately build down the stack to capture the end-to-end value.
In short, there are clear reasons why both Cursor and Windsurf have been building their own models—and why Cursor has raised $900M to maintain its market leadership position in the face of a competitive onslaught.
The battle for the AI engineer
For infrastructure providers, the battle is just beginning—and it’s being fought on two fronts.
Up the stack, infrastructure startups are fighting for developer attention by moving into the UI layer. Natural language has become the default abstraction and everything else is scaffolding. Yesterday’s developer tools are doing all that they can to remain the preferred choice and retain the communities that they’ve built amidst a sea change in the application building experience.
Down the stack, these developer tools are competing for agent attention in a quest to be the new default. Protocols like MCP highlight the need to be accessible to any number of front ends or AI agents, while acknowledging that someone else’s front end may eat your lunch (or send it to your closest competitor).
When the stack chooses itself, how do you stay relevant? The only option seems to be to wage war on both fronts—try to own an audience while remaining accessible to the audiences owned by others. In the end, attention is still all you need.
Thanks to Swyx for being a thought partner as always 🙏