Cursor's Parent Company Anysphere Uses Composer to Train Next-Gen AI: How Bootstrapped Iteration Is Changing Code Generation

Training AI with AI: Anysphere's Core Technical Strategy

Anysphere — the company behind Cursor — recently revealed an ambitious technical roadmap: using the previous generation of Composer to train the next generation of Composer. At first glance, this sounds a bit like a Russian nesting doll, but it points to an increasingly clear direction in AI development: deeply involving AI in its own iterative evolution.

Specifically, Anysphere has built an autoinstall system where earlier versions of Composer handle the configuration of development environments, paving the way for subsequent reinforcement learning (RL) training. Automatically setting up development environments may sound simple, but it's actually one of the thorniest problems in software engineering. A typical open-source project might depend on dozens of libraries, involve specific runtime versions, system-level dependencies, environment variable configurations, database initialization, and more. Even experienced developers often need hours or even days to set up an unfamiliar project. While containerization and declarative package management tools like Docker and Nix have alleviated some of these issues, many projects still have incomplete documentation and inaccurate dependency declarations, requiring manual troubleshooting. Anysphere's autoinstall system delegates this work to the previous-generation Composer, meaning the AI needs to understand a project's README files, Dockerfiles, package.json configurations, infer missing dependencies, resolve version conflicts, and verify successful configuration in a sandbox environment. This is itself a highly challenging AI task, and it speaks volumes about the engineering capabilities the previous-generation Composer has already achieved.

As a result, the next-generation model doesn't waste compute on foundational tasks like environment setup and can jump straight into more advanced learning stages.

Bootstrapped Training: From Environment Setup to Capability Leaps

What Is Bootstrapped AI Training?

At its core, this approach is a "bootstrapping" strategy. In computer science, bootstrapping is a classic concept — the most iconic example being using a C compiler written in C to compile a new version of the C compiler.

Bootstrapping has deep roots in computer science history. In 1962, computing pioneers Hart and Levin achieved the first implementation of a LISP compiler written in LISP — meaning a language could "compile itself" for the first time. Since then, compilers for nearly all mainstream programming languages (GCC, Rust, Go) have adopted bootstrapped development. The core philosophy of bootstrapping is this: once a system reaches a certain capability threshold, it can be used to build a more powerful version of itself. This concept has extended from compilers to operating systems (cross-compilation of the Linux kernel) and even hardware design (using chip design tools to design next-generation chip design tools). By bringing this classic paradigm into the AI training domain, Anysphere is essentially testing a hypothesis: have AI models crossed the "bootstrapping threshold" — that is, do they possess sufficient capability to meaningfully participate in the training process of their own successors?

Anysphere has applied the same logic to its AI training pipeline:

Previous-generation Composer handles foundational work: automatically setting up development environments, configuring dependencies, and preparing the infrastructure needed for training
Next-generation Composer performs reinforcement learning in this ready-made environment, focusing its efforts on tackling more complex programming tasks
Each generation of the model stands on the shoulders of its predecessor, with capabilities progressively advancing

Why This Strategy Deserves Attention

In traditional AI training pipelines, environment setup and data preparation require extensive manual intervention. Configuring development environments, managing dependencies, setting up testing frameworks — while these tasks are indispensable, they're ultimately repetitive labor. Delegating these tasks to a previous-generation model that already has the requisite capabilities doesn't just improve efficiency — more critically, it frees up training resources so the new model can devote all its "learning energy" to genuinely challenging problems.

How Reinforcement Learning Drives Composer's Code Generation Evolution

Based on publicly available information from Anysphere, reinforcement learning plays a central role in Composer's training. This aligns with the broader technical trajectory of the AI coding assistant space.

Reinforcement Learning (RL) differs fundamentally from traditional supervised learning. Supervised learning requires human-annotated "ground truth" answers, while RL lets models autonomously explore optimal strategies through interaction with an environment and reward signals. In the domain of code generation, RL's advantages are particularly pronounced because code is inherently verifiable — whether test cases pass and whether compilation succeeds are clear binary signals that serve as excellent reward functions. OpenAI's Codex, DeepMind's AlphaCode, and various recent coding LLMs have all adopted RL training to varying degrees. In terms of specific technical implementations, common approaches include RLHF (Reinforcement Learning from Human Feedback), RLAIF (Reinforcement Learning from AI Feedback), and methods that directly use unit test pass rates as rewards.

In a code generation scenario, a typical RL training framework includes the following elements:

Environment: Real development environments encompassing codebases, test cases, and build systems
Actions: Code modifications, command executions, and other operations output by the model
Reward signals: Whether tests pass, whether code compiles correctly, whether functionality meets expectations

Anysphere's innovation lies in the fact that it not only uses RL to train the model's coding abilities but also uses the previous-generation model to automate the construction of the complete environments needed for RL training — including repository cloning, dependency installation, test framework configuration, and more. The degree of automation in these steps directly determines the upper bound of RL training scale and efficiency. Having the previous-generation Composer build these RL training environments effectively means handing off the automation of the training process itself to AI. This creates a positive feedback loop:

Stronger model → Higher-quality training environments → More thorough RL training → Stronger next-generation model

Once this flywheel starts spinning, each iteration cycle has the potential to be more efficient than the last.

Industry Implications: Self-Accelerating AI Development and Competitive Moats

Early Forms of Recursive Self-Improvement

What Anysphere is doing today doesn't quite qualify as full-fledged "AI self-improvement" — the previous-generation model primarily handles standardized environment configuration work and isn't directly improving training algorithms or model architectures. But the extension of this path is worth contemplating: if AI could eventually participate in training data curation, reward function design, or even neural architecture search, the speed of self-iteration could undergo a qualitative leap.

Recursive Self-Improvement is one of the central topics in AI safety research. As early as 2000, mathematician and science fiction author Vernor Vinge proposed the concept of an "Intelligence Explosion": once AI can improve its own intelligence, the rate of improvement would grow exponentially, potentially surpassing human intelligence within an extremely short timeframe. This concept was later systematically elaborated by Nick Bostrom in his book Superintelligence and is a key reason why organizations like OpenAI and Anthropic have established AI Alignment research teams. Of course, Anysphere's current practice is still a considerable distance from true recursive self-improvement — the previous-generation model is only handling environment configuration, not touching model architecture design or training algorithm optimization. But the directional significance of this path cannot be ignored: from environment setup to data curation, from data curation to reward function design, from reward function design to architecture search — each step forward narrows the distance between AI and genuine "self-improvement."

First-Mover Advantage Could Be Further Amplified

The bootstrapped training strategy also has a competitive implication: teams with more mature previous-generation models naturally have higher efficiency in training next-generation models. This means the gap between leaders and followers could widen with each iteration cycle.

As of 2025, the AI coding assistant market has formed a multi-polar competitive landscape. GitHub Copilot holds a first-mover advantage backed by Microsoft and OpenAI, with over a million monthly active users; Cursor has emerged as a dark horse with its deeply integrated IDE experience and Composer functionality, regarded by many developers as the "next-generation programming environment"; and there are also products like Codeium (now rebranded as Windsurf), Amazon Q Developer, JetBrains' AI Assistant, and Google's Gemini Code Assist. In this space, the speed of model capability iteration is the decisive factor. Traditional competitive moats — such as user base and ecosystem integration — are certainly important, but if a company can achieve faster model iteration through bootstrapped training, the pace of its product experience improvement will consistently outpace competitors. This also explains why Anysphere's valuation had reached the multi-billion-dollar level by early 2025 — investors are betting on the compounding effect this technical approach enables.

For a product like Cursor that has already established a firm foothold in the AI coding assistant market, this technical roadmap promises to further strengthen its competitive moat. Latecomers not only need to catch up with current model capabilities but also face an opponent whose iteration pace is continuously accelerating.

What Cursor's Iteration Flywheel Means

Anysphere using the previous-generation Composer to train the next generation may appear on the surface to be an engineering-level efficiency optimization, but at a deeper level it reflects a fundamental trend in AI development: AI is increasingly participating in its own evolutionary process.

When the tools used to train AI are themselves AI, the iteration flywheel begins to self-accelerate. This isn't just the technical foundation for Cursor to maintain product competitiveness — it may also be a microcosm of the future evolution of the entire AI coding assistant industry, and the broader AI field as a whole. Whoever can get this flywheel spinning efficiently first is likely to seize the initiative in the next round of competition.

Key Takeaways

Anysphere uses the previous-generation Composer model to automatically set up development environments, preparing the ground for reinforcement learning training of the next-generation model
This bootstrapped training strategy allows the new generation of models to focus on learning to solve harder problems, rather than wasting resources on basic configuration
The approach creates a positive feedback loop: better models produce more efficient training environments, which in turn train stronger next-generation models
This practice could amplify first-mover advantages, further solidifying Cursor's competitive moat in the AI coding assistant market
The trend of AI participating in its own training pipeline signals that the early seeds of recursive self-improvement are taking shape