Cursor Did Nothing Wrong

@Yihao Zhang @Zhiyan Chen

August 14, 2026 — Cursor announced that it had officially become part of SpaceX.

Upon joining SpaceX, Cursor said it would gain access to the world's largest pool of compute resources, to be used for training stronger models at lower operating costs.

Just five months earlier, Michael Truell, one of Cursor's co-founders, had used a different set of words to describe the kind of company he wanted to build: independent and long-lasting.

Over the past two years, model companies have kept pushing into the application layer, and more people have begun to suspect that most AI application products are merely temporary interfaces layered on top of models. Every time a foundation model gains a new capability, a batch of applications loses its reason to exist.

Cursor was once the most powerful counterargument to this view. It grew faster than the vast majority of software companies. It was the first to turn models into a new way of working. And it convinced people that application companies could understand users better than model companies.

But in the end, the most successful AI application still merged into a system that owned models, compute, and capital — at a price of $60 billion.

This undeniably proved Cursor's value. But it also proved that value and independence are not the same thing.

What's interesting is that in a recent elsewhere article, "The 2026 Unified Midterm Exam for AI Applications," one question asked: among the so-called "big three" of applications — Manus, Liblib, and Genspark — which ones are training their own models? Over 61% of respondents answered, "more than one."

In taking a stage-by-stage look back at Cursor's story, we're trying to understand one question: for the long-term independent development of AI applications, is Cursor a proof or a counterproof?

No hand-waving

In 2019, Silicon Valley investor Ali Partovi sat in the café at the Computer History Museum in California and gave a programming problem to the young man across from him.

Partovi expected it to take an hour. But in less than ten minutes, the young man had finished — and turned around with a problem of his own. By the time Partovi solved it, his scratch paper was a mess, while the other person's derivation looked neat and orderly.

Partovi later recalled that he wrote an A+ next to the young man's name, then added a few stars. This meant: whatever this person did next, it was worth paying attention to.

The young man's name was Michael Truell. He had just turned 18.

Three years later, Truell and three other MIT students' names appeared together on the same company's shareholder register: Aman Sanger, Sualeh Asif, and Arvid Lunnemark.

All four studied math and computer science. All grew up in competitive programming environments. But before starting a company together, they had worked in pairs at two separate companies.

Truell and Sanger were high school classmates at Horace Mann School. Upon graduation, they were determined to build something together, but didn't know what — only that they wanted to avoid AI programming.

This choice stemmed from the fact that GitHub Copilot had already been announced, and code completion looked like an extremely crowded track.

By contrast, mechanical engineering was still wide open: no company had yet seriously put large models into CAD software to predict an engineer's next move in SolidWorks or Fusion 360.

The two began collecting CAD data, training their own models, and running their own inference, building an AI tool for mechanical engineering: Cursor. Soon they ran into difficulties: public CAD data was far scarcer than code, models overfit as soon as they were scaled up; language models didn't transfer well to CAD; and 3D spatial reasoning was one of the most obvious weaknesses of models at the time.

What truly stopped the project was a more fundamental problem: neither of them was a mechanical engineer. They couldn't tell whether the product was actually solving problems for engineers. Sanger later said that founders are best off being heavy users of their own product.

Truell described that period as "wandering in the desert." He said the earliest Cursor was a "solution in search of a problem" — they saw a technical capability first, then went looking for a scenario where it actually made sense.

On the other side, Asif and Lunnemark were working on something technically far more serious.

That company was called Anysphere Messaging, and it aimed to solve a problem where servers, unable to read content, should also not know whether any communication had taken place at all.

In November 2021, Lunnemark wrote an article explaining why this was worth doing. The title: "It Is Time to Move Beyond End-to-End Encryption." His examples included domestic violence hotlines, sources providing materials to journalists, and people participating in opposition group chats.

They treated it as formal cryptography research: open-source code, technical white papers, formally defined security goals for metadata-private messaging, and complete proofs for the protocol. Yet as a product, it was almost unusable.

To hide sender and receiver, real messages had to be placed in sufficiently large anonymity sets. The result: sending a message typically took five minutes, and server costs were high. To make the system truly secure required large numbers of ordinary users; but ordinary users didn't care enough about metadata privacy to accept these experience costs.

In August 2022, the team voluntarily shut down the project. That same day, Lunnemark wrote an article titled "Concreteness."

In it, he admitted that he had been immersed in a grand line of reasoning that fell apart when examined concretely. He attributed part of this to his own pride. As a lesson, he set himself a rule: when discussing any plan from now on, he had to specify who would use it, in what scenario, and how — "no hand-waving."

In mathematics, "hand-waving" refers to deliberately omitting complex logical details in a proof or explanation, using intuitive description to skip over these steps.

The two failed threads converged here.

They had both strongly realized: they needed to do concrete things whose correctness they could judge for themselves.

And code happened to be exactly such a world — already digitized at massive scale, compilable, runnable, and testable, with errors surfacing quickly. More importantly, writing code was something all four of them did every day.

At the end of 2022, both pairs got access to GPT-4 through OpenAI's early access program. They decided to return to the track they had initially tried to avoid: Anysphere became the company name, Cursor the product name.

A new house

In 2022, AI programming products typically existed as plugins.

This was the safest choice. Plugins were faster to develop, and didn't require convincing programmers to leave editors they had used for years. GitHub Copilot moved into VS Code and other development tools. Amazon's CodeWhisperer took the same path. Codeium tried to cover as many editors as possible.

AI programming looked like a business of adding new furniture to old houses.

The Anysphere team's judgment was the opposite: if models were eventually going to do more than complete a line of code — if they were going to take on a complete engineering task — then programmers would need more than a new piece of furniture. They would need a new house, redesigned around AI.

Models needed to see the entire codebase, not just the currently open file. They needed to modify multiple locations simultaneously, not just write a few lines after the cursor. Every modification had to be inspectable and reversible. Terminal output, test results, and code changes all had to enter the same feedback loop.

When models shifted from being advisors in a sidebar to being participants in the work, AI could no longer be just a feature at the edge of an editor. It needed to reorganize the entire interface.

So the four of them spent five weeks writing an editor from scratch. But once it reached external users, complaints immediately followed: not enough extensions, a poor terminal, incomplete language support, existing development habits that couldn't migrate.

Every complaint was valid. A mature editor requires more than a decade of accumulated compatibility; a team of a few people couldn't replicate that in five weeks.

They quickly abandoned the base they had written by hand and migrated Cursor onto Microsoft's open-source Code OSS.

Later, Cursor was often described as "a VS Code wrapper." But the actual sequence was the opposite: the team first wrote the product by hand to confirm which interfaces the model needed to control, then handed the compatibility problems of a traditional editor over to mature open-source infrastructure.

Code OSS solved extension, language, and user habit problems for Cursor. Cursor retained the right to reorganize the workflow: when the model appeared, which files it could see, how it modified multiple locations, and how users inspected and reverted those changes.

Independent of models or technology, Cursor's earliest advantage was simply realizing sooner than others that model capabilities don't automatically become products. Context, latency, interaction, modification, and verification together determine whether a model capability can enter real work.

Lunnemark later wrote in a technical article: if any AI feature even slightly degraded the normal experience of writing code, users — including himself — wouldn't use Cursor.

A typical example was Cursor's attitude toward latency. In one interview, the host casually said a code editor should be "fun." Lunnemark immediately replied: "Fast is fun."

Taking off with weight

In March 2023, Cursor officially launched. For nearly a year afterward, its revenue curve showed almost no visible change. By October of that year, the company's ARR had just crossed $1 million.

For a team of just a few people, this was already a decent business. But placed next to the nearly vertical growth curve that followed, it looks more like a long runway.

At the time, models could complete a line of code, explain a function, but could rarely understand an entire codebase reliably. They couldn't stably modify multiple files, nor continue searching for causes after a failed attempt. Cursor had already connected codebase, editor, and model together, but the variable determining the product's ceiling wasn't in its own hands.

They could only wait. And their willingness to wait owed largely to the future they could see.

As early as June 2022, before ChatGPT was even released, Sanger made a bet with Shengtong Zhang, who had won IMO gold at age 16: by June or July 2024, AI models would reach IMO gold level.

Asif himself had competed in three IMOs. His reaction was that Sanger had probably "lost his mind" — even though he too believed AI would advance, reaching IMO gold level within two years seemed wildly exaggerated.

Sanger was simply someone obsessively fascinated by scaling. For a period, he would walk around wearing a T-shirt printed with scaling laws curves and formulas.

Looking back two years later, Asif called that bet one of the most prescient wagers in the team. In 2024, DeepMind came within inches of the gold threshold.

Waiting didn't mean doing nothing. They kept the team small and burn low, continued improving context, latency, and interaction, and established one rule: whenever a new model appeared, integrate it immediately.

In October 2023, the month ARR had just crossed $1 million, Asif published a blog post titled Our Problems — essentially a to-do list for the company at that time:

• Not just predicting the next block of new code, but building a "copilot for edits";

• Developing systems that proactively discover bugs;

• Enabling the model to modify entire files or even entire directories;

• Building constrained agents that don't interrupt workflow;

• Getting the model to understand the entire codebase.

The most ambitious item he named "time warp": predicting what cross-file edits a user would make in the next 15 minutes.

Asif also wrote that the team used Cursor about twelve hours every day, so new problems kept emerging and priorities kept shifting.

The list was written. What was missing was the engine.

In June 2024, Anthropic released Claude 3.5 Sonnet. Its coding ability crossed a clear threshold: it could handle longer context, better understand codebases, complete cross-file modifications, and continue attempting after task failures.

Cursor quickly integrated this model, rebuilt its codebase understanding and multi-document analysis around it, and made it the default option.

Two months later, Andrej Karpathy wrote on X: "I'm trying VS Code Cursor + Sonnet 3.5 instead of GitHub Copilot."

More developers began migrating. Cursor, which had only about $1 million ARR in 2023, surpassed $100 million by early 2025; later that year, it crossed $1 billion.

But if Cursor had only been faster than others at integrating Claude, it wouldn't have become the company it later did. From Tab onward, Cursor showed itself to be different from comparable products.

The Tab feature let programmers type half a line of code, and the machine would predict what came next based on the current file, nearby code, and recent changes. It didn't wait for users to formulate a complete requirement — it offered the next suggestion as the action happened. Users accepted with a single Tab press, or kept typing to reject at zero cost.

Cursor later compressed server-side median response time from 475 milliseconds to 260 milliseconds. The two numbers differed by only about a quarter second, yet the experience was different: the former still felt like waiting for a distant server's reply, the latter approached something like part of human movement.

Subsequently, Cursor amplified this collaborative relationship step by step. The model first completed a line of code, then modified a section on command. With the multi-file editing feature named Composer, users could hand over a relatively complete objective and let AI understand the codebase while modifying multiple files simultaneously. Later, Composer gradually gained Agent capabilities including searching code, calling tools, running commands, and checking results. Once multiple Agents could work in parallel, the interface's center began shifting from "files" to "tasks."

Composer later also became the name of Cursor's self-developed model.

In summary, Cursor created a system for bringing models into real work.

Speaking of Microsoft in 2024, Sanger said that the pace of change in AI programming meant leading by mere months produced significant product differentiation. Cursor a year later had to make today's Cursor feel obsolete, or it was already too slow.

This was clearly valuable. But the problem was: the stronger the model, the more valuable Cursor became. Later, this also became its hardest constraint to escape.

The Only Way to Win

Before continuing Cursor's story, we need to understand what its moat actually was.

Truell recalled in 2025 that when they started Cursor in 2022, they were frequently asked: if AGI might eliminate numerous vertical applications within years, why build an application company at all?

They answered that Cursor was a long "messy middle." Model capabilities would advance unevenly, and users needed someone to organize different capabilities into usable products. As long as models couldn't directly complete entire jobs, the application layer could determine how models entered reality.

In a 2023 media interview, the team identified two platform risks:

On one side, Microsoft. The VS Code extension API didn't let third parties fully control the editor, while Copilot had deeper internal permissions — this pushed Cursor to build a complete editor itself.

On the other side, model providers. Like many application companies that came later, Cursor then believed "model neutrality" was a way to mitigate risk. Call different models for different tasks, use small models for low-latency operations, large models for complex reasoning, train specific models yourself, then combine all capabilities into the same workflow.

In 2024, the founding team told Lex Fridman: if innovation stopped, Cursor had no moat; the only way to win was to continuously improve the product.

Truell also said Cursor had no lock-in in the traditional sense — any accumulation could be pierced by the next product or model leap. He called it a "consumer-like moat" — users stayed only because you were still the best.

In the same year's interview with The Verge, he admitted that AI software's economic structure resembled AWS more: the more you used, the more costs rose. Cursor had become "a strange experiment between AI Labs and software companies."

Simply put, they knew before problems struck that "data flywheels" and "workflow barriers" couldn't provide long-term security. One key self-rescue move should be upward, into the model layer.

Slopes of Different Steepness

On January 5, 2026, Cursor held an all-hands meeting that employees described as "War Time."

At this moment, Claude Code under Anthropic was growing rapidly, and Cursor's dependence on this supplier was beginning to look dangerous. Truell demanded the team cut non-essential meetings, quickly mobilize personnel, and accelerate its own model R&D.

The problem had first surfaced over half a year earlier.

In June 2025, Cursor modified its $20 monthly individual Pro plan.

The old plan offered a fixed number of fast requests and unlimited partial usage; the new plan turned $20 into a model usage quota, deducted according to API pricing, with extra charges after depletion.

For complex programming tasks, the quota burned quickly. Some users didn't realize they had entered overage billing until receiving bills far higher than expected. Refund and cancellation posts began dominating Cursor's community.

Eighteen days later, Truell published an apology letter, admitting the company hadn't explained the adjustment clearly and promising to refund unexpectedly incurred charges.

From a product management perspective, this was merely a pricing incident. But it also first exposed another bill hidden behind Cursor's $20 subscription.

For traditional software, serving one more user usually incurs minimal marginal cost. AI Agents are different: every step forward consumes inference resources. The longer the task, the more context, the stronger the model called — the higher the cost. Users pay a fixed monthly fee, while Cursor pays model and cloud providers by token, cache, and compute resources.

Cursor sells users a fixed price, but buys from upstream a constantly rolling bill. And the better its product becomes, the more pronounced this problem grows.

Cursor and Anthropic thus formed a special dependency. Claude helped Cursor become one of the fastest-growing AI applications; Cursor was also once among Anthropic's most important API customers. Both benefited from each other's growth, but the interpretation rights for cost and supply lay not in Cursor's hands.

More troublingly, the "platform risk" Cursor identified in 2023 was correct — suppliers were becoming competitors.

In 2025, Anthropic brought Claude Code to market. Before launch, it was described as a research experiment; months later, it had become a rapidly growing commercial product. Anthropic didn't need to pay Claude API markups to external suppliers, and controlled model access, costs, and release cadence.

By early 2026, Claude Code's ARR had already exceeded Cursor's level at that time.

Microsoft applied pressure from another direction. Cursor relied on Code OSS for editor compatibility, but some important extensions remained Microsoft-controlled. Microsoft began restricting certain proprietary extensions from running in non-Microsoft editors, while putting more AI capabilities directly into VS Code.

Cursor's two earliest correct choices — building on Code OSS, and rapidly integrating the strongest models — respectively connected it to two powerful upstreams. And both upstreams could enter its market.

Anthropic moving down to applications, Microsoft protecting its platform — both were easily understandable business decisions. But the problem lay in the different slopes each faced when moving toward the other.

Model companies moving down to applications could use existing models, compute, and research teams; application companies moving up to models needed to acquire capital, talent, and compute resources anew.

Cursor's success actually accelerated this process. With every batch of new users, it simultaneously accomplished three things: generating more inference revenue for upstream, proving to upstream that the AI programming market was large enough, and producing more data about how developers used models.

The more successful it became, the more upstream resources it needed to buy; the more successful it became, the more reason upstream had to enter its market itself.

What's interesting is that this company's internal attitude toward growth was always skeptical. When Cursor crossed $100 million ARR, an internal Slack bot sent out a number notification; employees celebrated briefly, and the office quickly returned to normal.

At all-hands meetings, Truell would repeat one line: "Growth can hide poor execution."

Cursor proved that an application company can understand users better than a model company. But it hasn't proved that a company that understands users better can, over the long term, bear the costs, supply constraints, and competition determined by model companies.

Money Doesn't Solve the Problem

Cursor tried to escape this dependency.

As early as 2024, it began training its own models. After 2025, the pace of self-developed models visibly accelerated, with several generations of its proprietary Composer models released in succession.

Composer's goal was never to become an omniscient general-purpose model. What it truly possessed was developers' behavior on real tasks: how a requirement gets broken down, where an agent should search first, when to call tools, which modifications get accepted, and how to verify after failure.

This data was suited for post-training. Cursor could make models more familiar with its own product workloads, completing tasks like searching codebases, modifying files, and running tests at lower cost. Under the company's vision, a task that might cost several dollars or even over ten dollars using frontier models could be compressed to under one dollar with its self-developed models.

In March 2026, Cursor released Composer 2. Hours later, a developer discovered an uncleaned model ID in the API information, pointing to Moonshot AI's Kimi K2.5.

Initially, Cursor didn't disclose the base model source. As questioning grew, the company admitted that Composer 2 used Kimi's open-source model, explaining it as an authorized commercial partnership. Six days later, the team released a 46-page technical report, supplementing details on base model selection, data, and training processes.

The controversy centered on disclosure, attribution, and the boundaries of the word "self-developed." But it also demonstrated the realistic path for application companies entering the model layer: rather than completing pre-training from scratch, they could stand on existing open-source bases, concentrating resources on post-training and product adaptation.

Even so, training still required far greater compute than before.

Truell later wrote on Cursor's blog that the team wanted to push training further but was already "compute-constrained."

This is the hardest part for application companies to bypass when climbing upward.

Product design, developer relationships, and real feedback could help Cursor train models better suited for programming, but they don't automatically become GPUs, data centers, and electricity. Even without training foundation models from scratch, continuous post-training, large-scale inference, and rapid iteration remain a capital-intensive business.

Cursor was not short of capital.

In August 2024, the team raised $60 million at a $400 million valuation; four months later, another $105 million at a $2.6 billion valuation. In June 2025, the company completed a $900 million funding round, lifting its valuation to $9.9 billion; that November, another $2.3 billion brought it to $29.3 billion.

From $400 million to $29.3 billion took just over a year. By April 2026, a new round of at least $2 billion opened, with a proposed valuation of $50 billion.

But the faster the fundraising, the more it illustrated the problem: Cursor no longer needed just money to help a startup scale, but infrastructure requiring sustained investment of billions of dollars without interruption.

The new round could certainly continue buying compute, but couldn't make compute its own asset; it could extend Cursor's time remaining independent, but couldn't eliminate this fundamental dependency.

Q.E.D.

In April 2026, while negotiating its new funding round, Cursor received an acquisition proposal from SpaceX.

The agreement was a time window: SpaceX obtained a six-month exclusive acquisition option; if ultimately not exercised, it would pay $10 billion, and both sides would convert to a compute and model partnership. Two months later, both parties signed the final merger agreement, with an all-stock transaction valuing Cursor at approximately $60 billion.

What Elon Musk was truly buying, of course, was not just an editor.

The first asset was the developer entry point. Cursor had entered numerous enterprises and development teams, becoming the working interface where programmers call models, assign tasks, and review results. Whoever controls this interface gets closer to the most frequent and valuable set of behaviors in software production.

The second was data. Public code only shows what was ultimately written; Cursor held interaction information. Compared to static code, these behaviors are more suitable for training next-generation programming models.

The third was revenue and customer relationships. Cursor had proven that model capabilities could be organized into products users were willing to pay for continuously, and had entered enterprise procurement systems. For a company with models and compute, building these relationships from scratch is no easier than training models.

At $60 billion, calculated against roughly $4 billion in annualized revenue at the time, it corresponded to approximately 15x P/S.

For the other side of the negotiating table, Musk — with the Colossus compute cluster and Grok model system — could precisely provide what Cursor needed.

The assets each side lacked were in the other's hands.

This acquisition easily recalls Microsoft's $7.5 billion all-stock acquisition of GitHub in 2018: both transactions were buying developer entry points, but the assets purchased were not the same.

GitHub preserved code repositories, commit histories, permission settings, and team collaboration relationships. Once enterprises left, they would have to migrate years of accumulated core production materials, giving it high switching costs. What Cursor held was primarily developers' AI usage entry points, workflows, and behavioral data. This data is valuable for training models, but doesn't similarly lock in users: if another AI programming tool becomes better, developers can usually migrate quickly.

Thus, GitHub's value was easier to retain within the platform; Cursor's value was more easily absorbed by the owner of models and compute. The former is a platform asset capable of long-term defense; the latter is a strategic asset of high value but harder to defend.

The acquisition didn't negate Cursor's application value — quite the opposite, it reached a position where product capability alone couldn't solve problems precisely because it made the product sufficiently successful. $60 billion was itself a confirmation. But it revealed the difference between "creating value" and "retaining value."

On August 14, 2026, the deal closed. Anysphere became a wholly-owned subsidiary of SpaceX, with shareholders collectively receiving 389 million shares of SpaceX Class A common stock. But the ending began in October 2025.

That month, Lunnemark left three very short paragraphs on his blog — 72 characters expressing sadness, excitement, and gratitude — then departed. Eight months later, the remaining three founders signed the $60 billion merger agreement.

Anysphere is a combination of "any" and "sphere"; the meaning behind it may be the belief that any domain can be seen as a system capable of being solved. Code can be compiled, products can be tested, answers given by models can be verified.

Four years later, they encountered a problem with no test set: can becoming the most successful AI application and building an "independent and long-lasting company" be the same thing?

Before this problem appeared, Brie Wolfson — who had worked early at Stripe and Figma — observed intermittently at Cursor's office for roughly two months. She asked Asif what worried him most about building this company.

Asif's answer was: People start talking about the weather at meals.

During those two months, Wolfson observed that Cursor employees spent most of lunch and dinner discussing what they were building, problems they hadn't figured out, the future of technology and products. And Asif always worried that one day they would sit together with no real problems left to discuss.

Of the four people, three signed the contract. The first to leave, Lunnemark, founded a new company called Integrous, to research how to preserve human freedom in the face of greater intelligence.

References

Cursor Team, Cursor, "Cursor is now a part of SpaceX", 2026-08-14 Space Exploration Technologies Corp., U.S. Securities and Exchange Commission, "Form 8-K: Completion of Acquisition of Anysphere", 2026-08-14 Allie Garfinkle, Fortune, "Cursor's crossroads: The rapid rise, and very uncertain future, of a $30 billion AI startup", 2026-03-21 Shubhangi Goel, Charles Rollet, Business Insider, "Inside Cursor's wild rise", 2026-06-15 Ali Partovi, Neo / LinkedIn, "The Cursor prehistory", 2026-06-22 swyx, Alessio Fan, Latent Space, "Cursor.so: The AI-first Code Editor — with Aman Sanger of Anysphere", 2023-08-22 Arvid Lunnemark, Anysphere Messaging, "It Is Time to Move Beyond End-to-End Encryption", 2021-12-29 Arvid Lunnemark, Shengtong Zhang, Sualeh Asif, Anysphere Messaging, "Anysphere Messaging Post-Mortem", 2022-08-25 Shengtong Zhang, Arvid Lunnemark, Sualeh Asif, Cryptology ePrint Archive, "Formal Security Definition of Metadata-Private Messaging", 2022 Arvid Lunnemark, arvid.xyz, "Concreteness", 2022-08-25 Lenny Rachitsky, Lenny's Podcast, "The rise of Cursor: The $300M ARR AI tool that engineers can't stop using", 2025-05-01 Lex Fridman, Lex Fridman Podcast, "Transcript for Cursor Team: Future of Programming with AI | Podcast #447", 2024-10-06 Sualeh Asif, Cursor, "Our problems", 2023-10-12 AlphaProof and AlphaGeometry teams, Google DeepMind, "AI achieves silver-medal standard solving International Mathematical Olympiad problems", 2024-07-25 Anthropic, Anthropic, "Claude 3.5 Sonnet", 2024-06-20 Andrej Karpathy, X, "Programming is changing so fast...", 2024-08-23 Cursor Team, Cursor, "Series B and Automating Code", 2025-01-16 Cursor Team, Cursor, "Past, Present, and Future", 2025-11-13 Cursor Team, Cursor, "A new Tab model", 2025-01-13 Cursor Team, Cursor, "Introducing Cursor 2.0 and Composer", 2025-10-29 Casey Newton, The Verge / Decoder, "Why tech is racing to adopt AI coding", 2025-08-04 Michael Truell, Cursor, "Clarifying our pricing", 2025-07-04 Tim Anderson, DevClass, "VS Code extension marketplace wars: Cursor users hit roadblocks", 2025-04-08 Cursor Team, Cursor, "Introducing Composer 2", 2026-03-19 Anthony Ha, TechCrunch, "Cursor admits its new coding model was built on top of Moonshot AI's Kimi", 2026-03-22 Cursor Team, Cursor, "A technical report on Composer 2", 2026-03-27 Cursor Team, Cursor, "Cursor partners with SpaceX on model training", 2026-04-21 Cursor Team, Cursor, "Series A and Magic", 2024-08-22 Rashi Shrivastava, Forbes, "Engineers At OpenAI And Midjourney Are Using This $400 Million Startup's AI Coding Software", 2024-08-22 Marina Temkin, TechCrunch, "In just 4 months, AI coding assistant Cursor raised another $100M at a $2.6B valuation led by Thrive, sources say", 2024-12-19 Cursor Team, Cursor, "Series C and Scale", 2025-06-06 Mary Ann Azevedo, TechCrunch, "Coding assistant Cursor raises $2.3B, 5 months after its previous round", 2025-11-13 Marina Temkin, TechCrunch, "Sources: Cursor in talks to raise $2B+ at $50B valuation as enterprise growth surges", 2026-04-17 Sarah Wang, Matt Bornstein, Martin Casado, Andreessen Horowitz, "Cursor + SpaceXAI: the fastest iterating team wins", 2026-08-14 Richard Nieva, Anna Tong, Forbes, "Cursor Hits $4 Billion Annualized Revenue Ahead Of SpaceX IPO", 2026-06-08 Microsoft, Microsoft News Center, "Microsoft to acquire GitHub for $7.5 billion", 2018-06-04 Arvid Lunnemark, arvid.xyz, "Leaving", 2025-10-17 Brie Wolfson, Colossus, "Inside Cursor: Sixty days with the AI coding decacorn", 2025-11 Integrous Research, Integrous Research, "Integrous Research" Forbes Staff, Forbes, "Arvid Lunnemark", 2026-03-10

Cover image source: Joseph Wright 'of Derby', An Experiment on a Bird in the Air Pump, 1768, The National Gallery