Lessons from Building Cursor

Key Concepts

• Composer 1.5: A high-performance model trained primarily through Reinforcement Learning (RL), positioned between Sonnet 4.5 and Opus 4.5 in capability.
• Reinforcement Learning (RL): The core methodology used to train models to perform specific tasks (like semantic search or grep) that cannot be learned through standard pre-training.
• Cloud Agents: Autonomous agents running in the cloud that allow for long-running tasks, enabling a shift from local, laptop-bound development to persistent, server-side execution.
• Capability Jumps: Significant leaps in model performance that fundamentally change user workflows (e.g., the transition from manual coding to AI-assisted coding).
• Self-Driving Codebase: A future state where AI agents autonomously manage security, technical debt, bug fixing, and backlog management with minimal human intervention.
• Developer Experience (DevEx): The environment and tooling required for models to effectively test and run code; currently a major bottleneck for autonomous agents.

1. Model Development and Training

• Composer 1.5: The model is designed for speed and engagement. It is trained almost entirely through RL to excel at specific technical tasks.
• The Role of RL: RL is essential for teaching models to use tools effectively. For example, while previous models struggled with grep, RL allows Composer 1.5 to perform semantic searches across massive codebases in 1–3 queries, replacing dozens of manual grep operations.
• Infrastructure Challenges: Scaling RL requires massive compute (100 million+ CPU compute per year). This necessitates building custom infrastructure to orchestrate millions of concurrent sandboxes, as off-the-shelf cloud providers cannot handle this scale.

2. Cloud Agents and Long-Running Workflows

• The "Capability Jump": Cloud agents represent the next major shift. Currently, they are often slower and less intuitive than local agents, but they offer the advantage of persistence (not needing to keep a laptop open).
• Testing as a Requirement: A critical hurdle is that models must be able to test their own code. Once a model can verify its own output, usage of cloud agents is expected to increase by a factor of 10.
• Infrastructure for Longevity: Unlike traditional RPCs (which last milliseconds), agents can run for days. This requires robust workflow engines like Temporal or Re-state to handle failures and state management during long-running processes.
• Context Management: To handle long tasks, models use self-summarization. During RL, models are incentivized to write summaries or documentation for their "future selves," allowing them to maintain progress even when the context window (200k–1M tokens) is reached.

3. The Future of Engineering

• The "Managerial" Shift: As AI takes over the actual writing of code, engineers will transition into a "manager" role. They will oversee the AI, define goals, and ensure the "self-driving codebase" is functioning correctly.
• The Self-Driving Codebase: The speaker envisions a future where a significant portion of a company's R&D budget is allocated to autonomous agents that handle security (7%), tech debt (12%), bug fixing (25%), and backlog management (50%).
• The Browser Experiment: A case study where an AI agent (or harness) made 3,000–4,000 commits over three days to build a functional browser. This demonstrated that models are now capable of tasks that are beyond the reach of individual human developers.

4. Notable Quotes

• "I think, you know, March or April, everyone is kind of writing code by hand and December, no one is writing code by hand... coding kind of got solved in 6 months."
• "The model never yells at you when the dev ex is off... I think companies in the future will have some dev ex teams where you tell the model, please... here's all the nice ways of using this repository."
• "If you know your codebase will stay for many years, review every line of code. If your codebase is for a weekend, who cares?"

5. Synthesis and Conclusion

The industry is moving away from manual code entry toward a paradigm where engineers act as architects and managers of autonomous systems. The primary technical challenges are no longer just model intelligence, but the infrastructure of reliability—specifically, how to manage long-running agents, ensure they can test their own work, and maintain a "DevEx" that allows AI to interact with complex repositories as effectively as a human would. The ultimate goal is a "self-driving" development environment where the model is responsible for the correctness and maintenance of the code it produces.