The nine days that reset the stack

Start with the timeline, because the speed is the point. SpaceX debuted on Nasdaq on June 12, 2026, raising roughly $75 billion in what was reported as the largest IPO in history and valuing the company above $2 trillion. Four days later, on June 16, 2026, it confirmed an agreement to acquire Anysphere — the company behind the Cursor AI coding editor — in an all-stock transaction valued at about $60 billion, widely described as the largest acquisition of a venture-backed startup ever recorded.

A company used its four-day-old public stock as acquisition currency to buy the most widely deployed AI coding tool on the market. Under the merger terms, Cursor’s common and preferred shares convert into SpaceX Class A stock, with the exchange ratio set by a seven-day volume-weighted average of SpaceX’s share price near closing. The deal is expected to close in Q3 2026, subject to regulatory approval, after which Cursor becomes a wholly owned SpaceX subsidiary.

The option that made this possible was signed back in April 2026: SpaceX secured the right to either buy Anysphere for $60 billion later in the year or pay roughly $10 billion for a partnership, with a sizeable walk-away fee attached. The acquisition feeds SpaceX’s AI division, built around xAI, which it merged with earlier in the year, and which had struggled to dent the frontier market led by Anthropic, OpenAI, Google, and Meta. Buying Cursor is how SpaceX tries to catch up — not by training a better base model, but by owning the surface where developers actually work.

That is the thesis worth holding onto as we go: the value is migrating to the workflow layer. Whoever controls where code is written, reviewed, and stored controls the most valuable real estate in software. And in 2026 that layer is being contested on three fronts at once — ownership, architecture, and trust.

Four MIT students to $60B in under four years

Anysphere was founded in 2022 by four MIT graduates — Michael Truell (CEO), Sualeh Asif, Aman Sanger, and Arvid Lunnemark — and raised an early seed round led by the OpenAI Startup Fund. Cursor, the editor, launched in March 2023. What followed is one of the fastest revenue ramps in the history of business software.

The annual recurring revenue curve tells the story better than any narrative: roughly $100 million in January 2025, about $500 million by mid-year, past $1 billion by November 2025, and $2 billion by February 2026 — with Anysphere projecting north of $6 billion ARR by the end of 2026. By the time of the deal Cursor sat at roughly $4 billion annualized revenue, of which about $2.6 billion came from enterprise customers.

Reporting also notes the company had rebuffed acquisition interest along the way — Microsoft examined a deal before declining to bid formally, and Cursor’s leadership turned down approaches from OpenAI, having prioritized staying independent. The reach is what made it a target worth $60 billion: tens of thousands of enterprise clients, developers at a large share of the Fortune 500, and on the order of 150 million lines of enterprise code generated daily. That last number is not a vanity metric. It is the reason the version-control story in this article exists at all.

The margin trap that made a $4B company sell

Here is the part the price tag obscures. A business growing toward $6 billion ARR does not usually sell. Cursor did, and the reason is a structural squeeze that every AI application company should study.

Cursor’s product runs on frontier models it does not own. For much of its rise it paid retail API pricing to model providers — most visibly to Anthropic, whose Claude models powered a large share of Cursor’s coding — while those same providers ran their own competing coding products on wholesale economics. When your largest cost input is sold to you at retail by a company that also ships a rival product, your gross margin is structurally capped and partly controlled by a competitor.

The market data made the squeeze visible. Per one widely cited corporate-spending dataset, Cursor’s category share slid from roughly 41% in mid-2025 to about 26% by May 2026, even as its absolute revenue kept climbing — while a model provider’s own coding tool climbed toward half the category. Growing fast and losing share at the same time is the signature of a company winning the demand war and losing the margin war.

SpaceX’s pitch resolves the trap with vertical integration: data-center capacity, energy, and connectivity already inside the group, plus xAI’s models, mean Cursor’s marginal cost of intelligence can in principle drop toward the cost of running it rather than the cost of buying it. Whether that thesis holds through integration is the open question. But the direction of travel is clear, and it points straight at the next problem — what happens when intelligence gets cheap enough to write code continuously.

When code stops being typed and starts being generated

An AI coding agent is not autocomplete. It takes an instruction — “add error handling,” “fix the failing tests,” “migrate this module to the new API” — and rewrites multiple files at once, often across several turns of conversation. The unit of work is no longer a keystroke or even a function. It is an exchange between a human and an agent that produces a burst of edits.

At individual scale this is a productivity story. At population scale it is an infrastructure story. By one estimate, Claude Code alone accounted for around 4% of public commits on GitHub and was projected to exceed 20% of daily commits by the end of 2026. Multiply that across every agent in every editor and the composition of the world’s code history changes: a growing share of it is written by software, prompted by short natural-language instructions, with the reasoning that produced it living in a chat transcript that the version-control system never sees.

This creates a provenance gap. When a human writes code, the “why” lives in their head and, ideally, in the commit message. When an agent writes code, the “why” lives in the prompt and the back-and-forth that shaped it. Git records the final diff and discards the conversation. Six months later, staring at a block of agent-written code, the question “which instruction caused this, and what assumptions was the agent working under?” can be genuinely unanswerable from the repository alone.

That gap is the seam along which next-generation source control is being pried open.

Where Git quietly breaks under agents

Git is one of the most successful pieces of infrastructure ever built, and none of what follows is an obituary. But Git was designed in 2005 around a specific mental model: developers do a meaningful chunk of work, then deliberately save a snapshot — a commit. Everything between commits is invisible to the system by design. That model has a few load-bearing assumptions that agentic development strains.

None of this mattered much when humans wrote every line at human speed and carried the context in their heads. It matters a great deal when an agent rewrites five files in twelve seconds and the only record of intent is a sentence you typed and forgot. The pull request — the institution at the center of professional software for a decade — exists, in this framing, mainly to bring a discussion back to a snapshot of code after the two were separated. Remove the separation and the ceremony loses its reason to exist.

That is precisely the bet Zed is making.

DeltaDB: versioning every operation, not every commit

On June 11, 2026, Zed Industries — the team behind the high-performance Zed editor — opened the waitlist for DeltaDB, a version-control system with a different core abstraction. In a blog post, co-founder Nathan Sobo argued that the conversation generating code “is becoming the true source of our software,” and that Git, built around commits, was never designed to capture it.

Where Git stores a snapshot at each commit, DeltaDB breaks work into a stream of fine-grained deltas — individual edit operations — and gives each one a stable, addressable identity. The system records the agent’s message and the edit it produced side by side, so neither can drift away from the other. Technically it is built on operation-based CRDTs (conflict-free replicated data types), a class of distributed data structures formally defined in 2011 and already deployed inside databases like Redis, Riak, and Azure Cosmos DB, originally for collaborative text editing.

What the operation model unlocks

Critically, Zed frames DeltaDB as an evolution that interoperates with Git rather than an attempt to abolish it. The stated aim is not to replace Git or CI but to make the collaborative work that happens before a commit easier to capture. Git and CI get demoted to running checks; the day-to-day record of how software took shape moves to the operation stream. Zed plans to open-source it with an optional paid service, mirroring its editor model. A beta was slated to land within weeks of the June 11 announcement.

Zed is not entirely alone in the operation-based direction — academic efforts such as EvoGit have explored conflict handling through other structures — but DeltaDB is the most prominent commercial attempt to make the conversation, not the commit, the unit of version control.

Git vs AI-native version control, side by side

The comparison below is deliberately blunt. Real systems are messier, and DeltaDB’s column describes intent and early design more than battle-tested production behavior. Read it as a map of where the architecture diverges, not a scoreboard.

The pragmatic takeaway: for the foreseeable future these coexist. Git remains the source of truth and the thing CI runs against. The operation layer, if it proves out, sits on top and captures what Git was never built to hold. The interesting tension is cultural, not technical — if the conversation becomes the durable artifact, the pull request review stops being the main event, and a decade of team habits built around it have to find new homes.

The 2026 supply-chain reckoning

While ownership and architecture were being contested, trust was failing in public. If agents and operation-based history change how code is written, a brutal run of supply-chain attacks changed how seriously teams take where their secrets live. Two incidents anchor the year.

Shai-Hulud: the npm worm with a dead man’s switch

In November 2025, GitLab’s vulnerability researchers detailed an active, large-scale attack spreading through the npm ecosystem — an evolved strain of malware dubbed Shai-Hulud. It harvested credentials from GitHub, npm, AWS, GCP, and Azure, exfiltrated stolen data to attacker-controlled repositories, and propagated with worm-like behavior, automatically infecting other packages maintained by each victim. Most chilling was a “dead man’s switch”: if the malware lost access to both its propagation and exfiltration channels at once, it triggered destruction of data on the compromised machine — overwriting and shredding files to make recovery nearly impossible. An earlier wave tied to the same lineage had compromised hundreds of npm packages.

The Nx Console breach: when the editor is the entry point

The Nx ecosystem was hit twice inside a year. An August 2025 incident abused a misconfigured GitHub Actions workflow to steal publishing tokens and push trojanized packages — notable as one of the first documented cases of malware co-opting local AI CLI tools to help with reconnaissance. Then, on May 18, 2026, attackers published a malicious Nx Console v18.95.0 to the VS Code marketplace using a stolen contributor token. It was live for roughly 11 minutes, but estimates of affected installs ranged from a few dozen reported by the marketplace to potentially over 6,000 by the maintainers’ own analytics.

The payload was a credential stealer that swept tokens from GitHub, npm, AWS, HashiCorp Vault, Kubernetes, and 1Password — and, tellingly, AI coding-assistant configuration files — exfiltrating over HTTPS, the GitHub API, and DNS tunneling, with a persistent backdoor on macOS. It even carried Sigstore integration, meaning stolen OIDC tokens could be used to publish downstream packages with valid, cryptographically signed provenance — making malicious builds look verified. A group calling itself TeamPCP claimed responsibility and advertised the stolen data. CISA issued guidance. Nx shipped a patched build (18.100.0).

The defensive playbook teams actually adopted

GitHub alternatives and the case for self-hosting

A natural reaction to a bad security year is “should we leave GitHub?” It is worth being precise: the headline incidents were supply-chain compromises — poisoned packages and a trojanized editor extension — not breaches of GitHub’s own platform. Changing where your repositories live does not, by itself, stop a malicious npm package from stealing a token off a developer’s laptop. Migration is an control-and-architecture decision, not a patch.

That said, the appetite for alternatives is real, driven by concentration risk, the desire for control over CI and data residency, and — post-acquisition season — wariness about who ultimately owns the tools in the critical path. The main options:

Forgejo deserves a specific mention: a community-governed, open-source fork in the lightweight-forge lineage, it is the option for teams that want a self-hosted home for repositories without tying their fate to a single commercial vendor. The trade-off is the usual one — you inherit the operational burden of patching, backups, and uptime that a hosted provider otherwise carries. Self-hosting reduces third-party-platform risk while increasing your own operational risk. For some teams that swap is clearly worth it; for many it is not.

The GitLab project switch, in practice

If you do evaluate a move, the smallest meaningful unit is one project, not the whole organization. A sane migration looks less like a flag day and more like a pilot. The mechanics below are deliberately tool-agnostic; the order matters more than the exact commands.

The honest summary: tooling migrations are cheap to start and expensive to finish, because the repository is the easy part and the CI, integrations, and muscle memory are the hard part. Switch one project, learn what breaks, and let evidence rather than headlines decide whether the rest follows.

What this means for your team this quarter

Strip away the $60 billion headline and three durable shifts remain — each one a decision you can act on now rather than a spectacle to watch.

1 — Treat the workflow layer as strategic

The deal confirmed that where developers work is now worth more than many of the models they work with. When choosing editors and agents, weigh who owns them and where the lock-in accumulates, not just this month’s benchmark scores. Ownership changes, and the tool in your critical path can change hands in a single weekend.

2 — Start capturing agent provenance now

You don’t need DeltaDB in production to act on its thesis. Begin linking prompts to changes today: richer commit messages that reference the instruction, PR descriptions that include the agent exchange, and a norm that agent-written code carries its “why.” When operation-based tooling matures, teams that already value provenance will adopt it in an afternoon; teams that don’t will be reconstructing intent from diffs forever.

3 — Make supply-chain hygiene non-optional

Release-age delays, pinned versions, narrowly scoped tokens, and routine credential rotation are no longer advanced practice — 2026 made them table stakes. The single highest-leverage habit is reducing what any one stolen token can reach. Assume compromise is a question of when, and design so that when costs you a rotation, not a rebuild.

Frequently asked questions