Cursor just changed forever 🔗 **Source:** [Cursor just changed forever](https://www.youtube.com/watch?v=VgtfpTGJmHQ) > [!note]+ Document Notes > tags: [cursor, ide, ai-coding, composer-model, agents, development-tools] > author: Theo - t3․gg > source: YouTube > reference: https://www.youtube.com/watch?v=VgtfpTGJmHQ > date created: 2025-10-30 07:39 > > # 🏷️ Title: Cursor 2.0 First Look: New Agent Interface & Composer Model Deep Dive > <!-- deep-read:sections start --> ## 🧰 Action Inbox - [H1] Try Cursor 2.0's agent mode for multi-file editing tasks — Command+E toggle #development - [H2] Test Composer model speed vs other frontier models — 30 second completion claims #benchmarking - [H3] Experiment with parallel model comparisons — multiple agents on same task #testing ## 🧭 Table of Contents - [📝 Summary](#-summary) - [📖 Main Content](#-main-content) - [🗒️ Notes](#️-notes) - [📚 References](#-references) - [🗣️ Paraphrase](#️-paraphrase) - [📰 Newsletter](#-newsletter) - [✅ Action Items](#-action-items) - [🧪 Hypotheses](#-hypotheses) - [📊 Methodology](#-methodology) - [❓ Questions](#-questions) - [🔮 Future Research](#-future-research) - [💡 Implications](#-implications) - [🧠 Learning Styles Assessment](#-learning-styles-assessment) - [📊 Accessibility Assessment](#-accessibility-assessment) - [🌍 DEIB Assessment](#-deib-assessment) - [✅ Logical Validity](#-logical-validity) - [🛡️ DARVO Analysis](#-darvo-analysis) - [🎯 Conclusion](#-conclusion) ### 🔗 References - [Cursor 2.0 Announcement](https://cursor.sh) - [AI SDK v5 Migration Guide](https://sdk.vercel.ai/docs/upgrading) ## 📝 Summary - Cursor released version 2.0 with a new agent-focused interface and their first proprietary AI model called Composer - The update separates traditional editing (editor view) from AI agent work (agent mode) via Command+E toggle - Composer model claims 4x speed improvement over similar intelligence models, completing tasks in under 30 seconds - New features include parallel model comparison, git worktree support, enhanced code review interface, and integrated browser testing - Theo demonstrates real-time coding tasks showing significant workflow improvements despite some technical hiccups Key Insights for [Cursor just changed forever](https://www.youtube.com/watch?v=VgtfpTGJmHQ) by [Merlin AI](https://merlin.foyer.work/) **Cursor 2.0 Overview** - Cursor 2.0 introduces a new interface designed for managing multiple coding agents in parallel, enhancing user experience significantly. - The dual view feature allows users to toggle between "agent" and "editor" modes for better functionality and organization. - This update focuses on streamlining workflows, making it easier to run various tasks concurrently. **New Features and Innovations** - Composer, the new coding model, is four times faster than its predecessors, optimizing multi-step coding tasks. - Built-in support for work trees allows users to execute multiple processes without interference, enhancing productivity. - The interface features a modern design that prioritizes agent-based outcomes rather than traditional file-centric views. **Performance and Speed** - The Composer model is engineered to handle real-world coding challenges, improving speed and accuracy in outputs. - Users reported that the model completes most tasks in under 30 seconds, allowing for rapid iteration and testing. - Multi-file editing capabilities enable users to manage several files simultaneously, marking a significant advancement in coding efficiency. **User Experience Enhancements** - Cursor 2.0 simplifies code reviews, offering a new interface to inspect changes across multiple files efficiently. - The integrated browser tool allows agents to test their outputs in real-time, ensuring that code behaves as expected. - Users can seamlessly switch between reviewing changes and diving deeper into code, creating a more fluid development environment. **Future Implications** - The update encourages developers to experiment with multiple models, promoting a culture of testing and validation in coding practices. - As reliance on AI agents grows, the Cursor team aims to address bottlenecks in code review and testing processes with continuous improvements. - The updates signify a shift towards leveraging AI for more complex coding tasks, showcasing the potential for increased collaboration between human developers and AI models. ## 📖 Main Content Cursor 2.0 represents a fundamental shift from file-centric to agent-centric development workflows. The company, leveraging their SuperMaven acquisition and Jacob's expertise in fast code completion, has developed Composer - a frontier model optimized for speed and multi-file editing capabilities. The interface redesign separates concerns: traditional editing remains in editor view while AI agent work happens in dedicated agent mode. This allows developers to run multiple agents in parallel using git worktrees without interference, enabling comparative analysis across different models on the same task. The Composer model was trained on real-world software engineering challenges with access to production search and editing tools. This training approach, combined with reinforcement learning from user acceptance data, appears to deliver competitive results at significantly faster speeds than existing frontier models. Technical innovations include native browser integration for testing agent changes, improved code review flows with Monaco-style rendering, and intelligent context awareness that reduces the need for explicit retrieval instructions. ## 🗒️ Notes #### ⏱️ [00:00](https://www.youtube.com/watch?v=VgtfpTGJmHQ?t=0) — [H1] Cursor 2.0 Interface Overview - Key idea: New agent mode separates from traditional editor with Command+E toggle - Evidence: "You'll notice this little toggle at the top between agent and editor views" #### ⏱️ [01:30](https://www.youtube.com/watch?v=VgtfpTGJmHQ?t=90) — [H2] Composer Model Introduction - Key idea: Cursor's first proprietary model claims 4x speed improvement over similar intelligence - Evidence: "Composer is a frontier model that's four times faster than similarly intelligent models" #### ⏱️ [02:45](https://www.youtube.com/watch?v=VgtfpTGJmHQ?t=165) — [H2] SuperMaven Acquisition Context - Key idea: Jacob from SuperMaven brought autocomplete expertise that enabled Composer development - Evidence: "Jacob who used to be the creator of Tab 9... they've managed to make the tab complete and cursor the best in the world" #### ⏱️ [04:20](https://www.youtube.com/watch?v=VgtfpTGJmHQ?t=260) — [H1] Real-time AI SDK Migration Demo - Key idea: Live demonstration of upgrading project to AI SDK v5 shows actual model speed - Evidence: "This is all real time. We're not going to edit or speed this up at all" #### ⏱️ [06:15](https://www.youtube.com/watch?v=VgtfpTGJmHQ?t=375) — [H2] Parallel Model Comparison Feature - Key idea: Multiple models can work on same task simultaneously for result comparison - Evidence: "I want to update the UI... with three different models in parallel at the same time" #### ⏱️ [08:30](https://www.youtube.com/watch?v=VgtfpTGJmHQ?t=510) — [H3] Enhanced Code Review Interface - Key idea: New review flow provides Monaco-style rendering with file-by-file changes - Evidence: "There's a new view that shows you each of the files with like proper VS Code Monaco style rendering" #### ⏱️ [12:00](https://www.youtube.com/watch?v=VgtfpTGJmHQ?t=720) — [H2] Git Worktree Integration - Key idea: Parallel agents use git worktrees to avoid interference between tasks - Evidence: "Cursor 2.0 makes it easy to run many agents in parallel without them interfering with one another. Powered by git work trees" #### ⏱️ [15:45](https://www.youtube.com/watch?v=VgtfpTGJmHQ?t=945) — [H1] UI Generation Capabilities Demo - Key idea: Composer handles user interface creation effectively with real-time generation - Evidence: "Creates a to-do list... It grinds out an X.js package JSON... This is all real time" #### ⏱️ [18:20](https://www.youtube.com/watch?v=VgtfpTGJmHQ?t=1100) — [H3] Model Performance Comparison - Key idea: Different models show varying strengths in UI design and implementation approach - Evidence: "GPT5 is really good at this... In some ways, better, in some ways worse" #### ⏱️ [20:30](https://www.youtube.com/watch?v=VgtfpTGJmHQ?t=1230) — [H2] Native Browser Integration - Key idea: Agents can test changes in integrated browser and iterate based on visual results - Evidence: "We've also built a native browser tool that allows Cursor to test its work and iterate" #### ⏱️ [22:45](https://www.youtube.com/watch?v=VgtfpTGJmHQ?t=1365) — [H3] Automated Screenshot and Fix Loop - Key idea: Browser integration enables autonomous testing and correction cycles - Evidence: "It just successfully spun up a browser, fixed the UI problems, and then made the right changes" #### ⏱️ [24:00](https://www.youtube.com/watch?v=VgtfpTGJmHQ?t=1440) — [H1] Workflow Impact Assessment - Key idea: New features are changing development practices toward more testing and model comparison - Evidence: "I am more willing to try multiple models... I'm even starting to write more tests" ## 📚 References - [Cursor 2.0 Official Release](https://cursor.sh) - [SuperMaven Acquisition](https://cursor.sh/blog/supermaven) - [AI SDK v5 Migration Documentation](https://sdk.vercel.ai/docs/upgrading) ## 🗣️ Paraphrase - Cursor 2.0 fundamentally redesigns the coding interface by separating traditional file editing from AI agent interactions, allowing developers to focus on outcomes while agents handle implementation details - The new Composer model represents Cursor's first proprietary AI, trained specifically for software engineering tasks with emphasis on speed and multi-file editing capabilities - Integration of browser testing, parallel model comparison, and git worktree support creates a comprehensive development environment that reduces context switching and manual verification steps ## 📰 Newsletter **Cursor 2.0 Transforms AI-Assisted Development** The WordPress development community should take note of Cursor's latest release, which introduces game-changing improvements to AI-assisted coding workflows. The new agent-focused interface and proprietary Composer model offer significant speed improvements for common WordPress development tasks. Key benefits for WordPress developers include faster theme customization, plugin development acceleration, and improved debugging workflows. The parallel model comparison feature could be particularly valuable when working on complex WordPress customizations where multiple approaches might be viable. The integrated browser testing capability could revolutionize WordPress theme development by allowing AI agents to automatically test responsive designs and fix layout issues without manual intervention. Resources: [Learn WordPress](https://learn.wordpress.org/), [Developer Docs](https://developer.wordpress.org/), [WP-CLI](https://wp-cli.org/) ## ✅ Action Items #### DevRel - Developer advocacy: Create tutorials showing Cursor 2.0 integration with popular frameworks - Education: Develop workshops on AI-assisted development best practices - Developer experience: Document optimal model selection strategies for different task types - Developer marketing: Showcase speed improvements in real development scenarios - Community management: Gather feedback on new interface adoption challenges #### OSPO - Policy & Governance: Evaluate proprietary AI model implications for open source projects - License Compliance: Review Cursor's data usage policies for enterprise adoption - Security Management: Assess browser integration security implications - Software Inventory: Track AI model dependencies in development workflows - Developer Support: Provide training on responsible AI coding practices - Community Engagement: Share learnings about AI-assisted open source contribution - Strategic Alignment: Align AI tooling adoption with open source principles #### Community - Maintainers: Evaluate AI assistance impact on code review processes - Contributors: Provide onboarding materials for AI-assisted contribution workflows - Sponsors: Measure productivity improvements from AI tooling investments - Ecosystem: Coordinate standards for AI-generated code quality #### WordPress - Core: Assess AI assistance for complex refactoring tasks - Core Performance: Use parallel model comparison for optimization strategies - Core AI: Study Cursor's reinforcement learning approach for WordPress AI features - Core Program Team: Integrate AI assistance into coordination workflows - Mobile: Leverage browser testing for responsive WordPress app development - Playground: Explore AI-assisted WordPress environment setup - Community: Create guidelines for AI-assisted WordPress development - Training: Develop AI-assisted WordPress development curricula - Marketing: Showcase WordPress development speed improvements - Support: Use AI assistance for faster troubleshooting documentation - Design: Leverage AI for rapid WordPress theme prototyping - Documentation: Accelerate DevHub content creation with AI assistance #### The WPCC - Programs: Evaluate AI tooling stipends for contributors - Projects: Use AI assistance for documentation sprint acceleration - Funding: Assess cost-benefit of AI development tool subscriptions #### FAIR - Technical independence: Ensure AI assistance doesn't create vendor lock-in - Policies: Establish guidelines for AI-generated code attribution - Governance artifacts: Update contribution policies for AI assistance usage ## 🧪 Hypotheses - Cursor's proprietary model training on user acceptance data produces better developer-specific results than general-purpose models - Agent-focused interfaces reduce cognitive load compared to traditional file-centric IDEs for complex multi-file tasks - Parallel model comparison leads to higher quality code outcomes than single-model approaches - Integrated browser testing significantly reduces manual verification time in web development workflows ### 📊 Methodology - A/B testing comparing development task completion times between Cursor 2.0 and traditional IDEs - User experience studies measuring cognitive load in agent vs editor modes - Code quality analysis of single-model vs multi-model comparison outputs - Time-motion studies of browser testing integration impact on development cycles ### ❓ Questions - How does Cursor's proprietary model training affect code quality compared to frontier models like GPT-4 or Claude? - What are the long-term implications of IDE companies developing their own AI models for the competitive landscape? - How will the separation of agent and editor interfaces influence developer workflow patterns and tool adoption? ### 🔮 Future Research - Investigation of optimal model selection strategies for different development task categories - Analysis of AI-assisted development impact on code maintainability and technical debt - Study of collaborative development workflows when team members use different AI assistance levels ### 💡 Implications - Practice: Developers may need to restructure workflows around agent-centric rather than file-centric paradigms - Policy: Organizations should establish guidelines for proprietary AI model usage in development - Security: Browser integration in development tools creates new attack vectors requiring evaluation - Education: Developer training curricula need updates to include AI-assisted development best practices - Funding: Development tool subscriptions may become significant budget items as AI features differentiate offerings ### 🧠 Learning Styles Assessment Reading level estimate: 12th grade #### 👀 Visual learners - Present: Multiple screenshots of interface changes, real-time screen recordings - Improve: Architecture diagrams showing agent vs editor separation, model comparison flowcharts #### 🔊 Aural learners - Present: Video format with narrated demonstration - Improve: Podcast-style discussion of implications, audio-only summary version #### 🗣️ Verbal learners - Present: Clear definitions of new terminology, analogies to traditional development - Improve: Glossary of agent-specific terms, comparison tables between old and new approaches #### 🧩 Kinesthetic learners - Present: Live coding demonstration, real-time problem solving - Improve: Step-by-step tutorials, hands-on exercises with sample projects #### 🧠 Logical learners - Present: Performance benchmarks, systematic comparison of model outputs - Improve: Decision trees for model selection, quantified productivity metrics #### 🧑‍🤝‍🧑 Social learners - Present: Community reactions and testimonials - Improve: Discussion forums, collaborative evaluation projects #### 🧘‍♀️ Solitary learners - Present: Detailed technical analysis, individual exploration opportunities - Improve: Self-assessment checklists, personal workflow optimization guides #### 🌿 Naturalistic learners - Present: Real-world development scenarios and practical applications - Improve: Ecosystem impact analysis, natural workflow evolution patterns ### 📊 Accessibility Assessment #### Screen reader semantics - Present: Video has verbal descriptions of interface elements - Improve: Detailed alt text for screenshots, structured heading hierarchy in documentation #### Keyboard navigation - Present: Mentions keyboard shortcuts like Command+E - Improve: Complete keyboard navigation guide, accessibility testing of new interface #### Contrast and readability - Present: Dark mode interface examples - Improve: Contrast ratio verification, readability testing across different themes #### Text resizing and reflow - Present: Interface appears responsive in demonstrations - Improve: Explicit testing at 200% zoom, text scaling verification #### Media and captions - Present: Video content with clear audio - Improve: Closed captions, transcript availability, audio descriptions of visual elements #### Forms and interactions - Present: Interface interactions demonstrated - Improve: Accessibility testing of new agent interface elements, screen reader compatibility #### Standards reference - Map interface changes to WCAG 2.2 AA compliance requirements ### 🌍 DEIB Assessment #### Cultural breadth - Present: English-language focused content - Improve: Multi-language interface examples, global developer perspective inclusion #### Inclusive language - Present: Technical terminology well-defined - Improve: Plain language summaries, avoidance of developer-exclusive jargon #### Neurodiversity support - Present: Clear section breaks, consistent structure - Improve: Cognitive load analysis of agent vs editor interfaces, attention management features #### Representation - Present: Single developer perspective - Improve: Diverse developer experiences, various skill level perspectives #### Psychological safety - Present: Acknowledges potential bias from investment - Improve: Balanced criticism inclusion, community feedback integration ### ✅ Logical Validity #### Strong reasoning - Deductive strength: Performance claims supported by demonstrated examples - Inductive strength: Generalizes from specific coding tasks to broader development workflows - Causal reasoning: Links SuperMaven acquisition to Composer model capabilities - Analogical strength: Compares new interface paradigm to established development patterns #### Fallacies - Appeal to authority: Relies heavily on Ben's testimonial without broader validation - Hasty generalization: Extrapolates from limited demo scenarios to general performance claims - Cherry-picking: Shows successful examples while acknowledging but not deeply exploring failures #### Tone of voice - Overall tone: Enthusiastic but self-aware, acknowledges bias and limitations while maintaining genuine excitement about technical improvements ### 🛡️ DARVO Analysis - Deny: No denial patterns present - acknowledges investment bias and technical limitations - Attack: No attacks on competitors or critics - Reverse victim/offender: No victim/offender dynamics present - Emotional cues and rhetoric: Excitement and technical enthusiasm balanced with transparency about financial interests and technical shortcomings ## 🎯 Conclusion Cursor 2.0 represents a significant evolution in AI-assisted development tools, moving beyond simple code completion to comprehensive agent-driven workflows. The combination of the new interface design, proprietary Composer model, and integrated testing capabilities suggests a maturing approach to AI development assistance that prioritizes speed, parallel processing, and autonomous iteration. For practitioners, the key insight is the shift from file-centric to outcome-centric development workflows, where developers focus on specifying desired results while AI agents handle implementation details. The parallel model comparison feature particularly stands out as a method for improving code quality through competitive AI approaches. The success of Cursor's proprietary model development indicates that specialized AI training for software engineering tasks may yield better results than general-purpose models, potentially influencing how other development tools approach AI integration in the future. ## 🧱 Refactor Appendix ### 📚 Literature Split Pad Purpose: Stage CEE units that become Literature notes. Split level: H3 ### [H1] Cursor demonstrates agent-centric development interfaces improve workflow efficiency > [!quote] [Cursor 2.0 First Look](https://www.youtube.com/watch?v=VgtfpTGJmHQ) by [[Theo - t3․gg]] via [[YouTube]]. Published 2025-10-30. Accessed 2025-10-30. > "More focus and design from the ground up to be centered around agents rather than files." Interface separation allows developers to focus on outcomes while agents handle implementation details, reducing context switching between planning and coding modes. [view highlight](https://www.youtube.com/watch?v=VgtfpTGJmHQ?t=720#H1) #xref #articleseed ID:rw_cursor_agent_interface ### [H2] Proprietary AI models trained on developer acceptance data outperform general models > [!quote] [Cursor 2.0 First Look](https://www.youtube.com/watch?v=VgtfpTGJmHQ) > "They can use that to replicate the outputs that they get from other models that were accepted by the users." Reinforcement learning from user acceptance patterns enables domain-specific model optimization that general-purpose training cannot achieve. [view highlight](https://www.youtube.com/watch?v=VgtfpTGJmHQ?t=945#H2) #xref ID:rw_composer_training_method --- ### 🔖 Atomic Split Pad (Zettel Candidates) Purpose: Promote reusable claims into Atomic notes. Split level: H4 #### [Z1] Parallel model comparison improves code quality through competitive approaches - Applies to any multi-model AI system with quality assessment capability - Reference: 18:20 timestamp showing different model UI generation approaches - Links: [[AI-Model-Selection]] [[Code-Quality-Assessment]] #### [Z2] Browser integration enables autonomous testing and iteration cycles for AI agents - Relevant for any AI system that generates user-facing interfaces - Reference: 22:45 timestamp demonstrating automated fix loop - Links: [[AI-Testing-Automation]] [[Browser-Automation]] --- ### ✏️ Fleeting Queue Purpose: Capture quick actions for Fleeting notes. - [F1] Test Cursor 2.0 agent mode with WordPress plugin development — practical evaluation #fleeting #inbox - [F2] Compare Composer model performance on frontend vs backend tasks — speed/accuracy analysis #fleeting #inbox - [F3] Investigate git worktree setup for parallel development workflows — tool configuration #fleeting #inbox <!-- deep-read:sections end --> ## 📺 Video  --- # 📄 Full Transcript *Auto-generated from YouTube captions · timestamps roughly every 30 seconds · [watch on YouTube](https://www.youtube.com/watch?v=VgtfpTGJmHQ)* **[00:00]** Cursor 2.0 is here and they changed way more than I expected. If we hop to the edit huh, that looks nearly identical to what I'm used to. I thought they changed everything. That's because I'm in the editor view. You'll notice this little toggle at the top between agent and editor views. You can also press command E to switch between the two. And when I press command E, you'll see the new cursor experience. This is agents mode. This is their new view for managing all of the things that you're running potentially even in parallel in your code projects inside of Cursor. It has been the only way I've coded for a few **[00:30]** days now and I'm genuinely really impressed. I never thought I would like an interface like this, but they really get it. Cursor team's been going hard on this UI for quite a bit now and the results speak for themselves. There are so many little things I'm excited to talk about here from the built-in work tree support so you can run multiple things in parallel on your machine to the ability to run multiple models at the same time to compare results to my new favorite thing, Composer 1, the official model that was made by Cursor. Yes, they shipped a new model that they made themselves alongside all of this. I **[01:01]** am an investor in Cursor, so make sure you account for any bias I might have there. It's never stopped me from being harsh on them in the past, and it certainly won't in the future. So, you can take my word for how good it is, or you can listen to other people like my manager, Ben, who has no financial incentive whatsoever to like Cursor. In fact, he's had his own issues with him in the past. Yeah, man. This is my GPT5 moment, LMAO. They [ __ ] killed it with this. The new model plus Cursor 2.0 is truly insane. Yeah, it's a good model and overhaul. I'm so excited to break down all the cool things this does right after a quick word from today's sponsor. LMS have gotten super smart and we're **[01:32]** building really cool apps with them. But no model can be smarter than the data it has access to. And it'll be a hell of a lot smarter if it has access to the data that your users need. Things like their Google Drive, their notion, their Slack, and more. So, how do you add that? Do you build each of those integrations yourself? I certainly hope not because today's sponsor, Raggy, will make it so much easier. Their Rag is a service, but it goes so much further than that. They have the platform you need to integrate your users data into your AI applications easier than ever before. It's hilariously easy to integrate. We're literally talking like five lines **[02:02]** of code. And if you want users to be able to off with their own stuff, it's seamless to do. They have connectors for everything your users would reasonably want. Even stuff like Salesforce, users click the platform they want data from, they sign in, they click the things they want, and you're done. If this is all they did, it would be worth it. But they do so much more, too. They're working on this new concept of contextaware tools where the tool calls are provided the context at start so they don't have to go find the context later which makes them way more accurate and reliable over time. If you're tired of having to write instructions like use the retrieval tool **[02:33]** to answer this. Raggy's figuring this all out. You can see here how they fill in the context hole so the model can behave correctly. This is awesome. It's like prompt enhancing with more knowledge of the data that the model has access to and the result is just better outputs. If you're trying to bring your users data into your applications, check them out now at soy.link/raggy. Before we got dive too deep into the editor, let's take a look at what the cursor team has to say. Introducing Cursor 2.0 and Composer. Today, releasing two big updates that make Cursor the best place to work with agents. Our first coding model, Composer, and a new interface for **[03:03]** working with many agents in parallel. Composer is a frontier model that's four times faster than similarly intelligent models. That's part of what's so cool about it. Composer just it flies. Turns out Cheetah, that model that's been hiding inside of cursor for a bit, was actually by them and it was an early version of what has become composer. It completes most turns in under 30 seconds. Early testers found the ability to iterate quickly with the model delightful. They trust the model for multi-step coding tasks. If you're curious how the hell they managed to get a model this good at cursor when they're mostly an IDE company, that comes back **[03:33]** to an acquisition they made a while ago. Remember Super Maven? Super Maven is the fastest co-pilot. was the tab complete model that I got really hyped about way back that was built by Jacob who used to be the creator of Tab 9. He has been obsessed with autocomplete code stuff forever and really really focused on responsive models that learn from you and work super fast. Because he has been so locked in on this, they've managed to make the tab complete and cursor the best in the world by far. And he didn't want to stop there. Jacob and team kept **[04:03]** going and the result is this new model composer the fast frontier model with reinforcement learning. We achieved these results by training the model to complete real world software engineering challenges in large code bases. During training composers given access to a set of production search and editing tools and tasked with efficiently solving a diverse range of difficult problems. The final results a large scale model optimized for high-speed use as an agent in cursor. In their benchmarks it is close to the best frontier models and way way faster. And there's one other piece that makes it even faster than this indicates. They can edit multiple **[04:34]** files in parallel with it. That's why it's called composer. It's able to do multi file editing and plan stuff in a way that feels fundamentally different. I could keep telling you about it, but I'd rather show you. So, this is SnitchBench, the benchmark I made for testing how likely a model is to snitch on you. And I want to update it to AISDK v5. I found this to be a weirdly difficult task for various models. So, let's throw it at this. I'm going to grab the link to the uh AISDK v5 upgrade v4 migration guide. Here's the migrate SDK 4.0 to 5.0. I'll drop this link. I **[05:06]** want to upgrade this project to use the latest AI SDK ZOD and open router providers. Here's a link on how to do the AI SDK v4 to v5 migration. And now we submit it. This is all real time. We're not going to edit or speed this up at all. You're seeing how quickly it churns through and crunches all of this stuff. **[05:37]** Scrubbing all the files creates a to-do list. I found that the slowest things with this model are things like searching or running npm commands. I go out of my way to tell it to always use bun because it historically just it the npm is the thing that slows this down. And you see here as it's editing it's just grinding through files. Let's say I want to do something else **[06:08]** while this is going. I can click new agent. I will change this be a work tree. By default it's picking multiple different models for it. I don't necessarily need that. I'll turn off multiple models. Although it is very cool you can do that to compare things. Now you know what let's do it. Actually I'm curious multiple models five codecs composer. I'll throw haiku in here as well. I want to update the UI for this benchmark. Instead of just printing lines to the CLI whenever a test runs make a table that will show how many test runs have **[06:38]** completed for each model in a set of rows. It should indicate how many tests are running, how many have completed, and how many have failed. It should also show the average time to complete for a given model. So, let's run this with three different models in parallel at the same time we're doing all of the other work you just saw. And look at that. The other task finished. It did not take very long. Eight of eight to-dos complete. It just grinded through all of that. And I want to take a look. So, let's do that. Let's just try running it and see if it works. Oh no, **[07:10]** we're getting errors. Undefined is not an object. Did I not uninstall? I'll just do the usual copy paste the error. Let it figure that out while at the same time these are running in parallel. And isn't it cool? You can see how each one's doing. GBT5 hasn't even started writing code yet because it's so heavy on planning. Haiku has been writing code for a bit now. Composer is just grinding as it tends to. Although we're seeing a bit of mistakes. The string to replace was not found in the file. It's just adding and deleting this table display over and over again. So, it's choking a **[07:41]** little bit. Happens. And do I have to click here to configure a work tree setup script? Bun install. Save. Done. Composer is now done. We can hit review and see the new review flow. This is one of the coolest things with this update. There's a new view that shows you each of the files with like proper VS Code Monaco style rendering. You can see for each piece what changed and review it all in one pass. It's actually really nice cuz it switches between the different files. You can expand and **[08:12]** collapse them. Show the whole file. This is a good view for this type of thing. Meanwhile, this is running. Tells you to npm install or bun install. Migrations complete. Let's bun install. Bun run index.ts. Skipped already completed tests. That's a very good sign. Let's go rename one of the base models quick so that it will actually run and we can be sure it's running properly. Constants. What's a cheap one in here? Um 04 mini is cheap. Not fast, but it's cheap. So, we'll do 04 mini-1 just to force it to **[08:43]** rerun. Not looking good. We'll tell it what the behavior was. For what it is worth, I did the same tests before and have a PR up with it changed. So, I know it is capable, but this is the nature of LLMs. They are nondeterministic at best. When I tried running the code, it finished almost immediately. It said all of the tests took 0.04 seconds to run. This seems wrong. What might be causing the tests to not actually run and complete? **[09:15]** Oh, looks it missed a change in the response structure. Happy that I figured that out. I just realized I forgot to finish reading the blog posts. Let's do that. So, as I said, new model, really cool, super fast, as you're seeing it just chug along through all this. I'm very impressed. But the interface is what you're seeing more of here. More focus and design from the ground up to be centered around agents rather than files. So you can focus on the outcomes you want while agents take care of the details. When you need to deep dive into the code, you can still easily open files in the new layout or switch back to the classic IDE. Cursor 2.0 makes it easy to run many agents in parallel **[09:46]** without them interfering with one another. Powered by git work trees or with remote machines, we even found that having multiple models attempt the same problem, picking the best result significantly improves the final output, especially for harder tasks. As we use agents more for coding, we've seen two bottlenecks emerge. Reviewing code and testing the changes. With cursor 2.0, we're also starting to solve both of those. We made it much easier to quickly review the changes that agents have made and dive deeper into the code when you need to. We've also built a native browser tool that allows Cursor to test its work and iterate until it's produced the correct final result. Yes, they **[10:17]** snuck a browser into Cursor as well where the AI agents can play with that browser, click things, check things, and make sure everything's working how you would expect it to. Super cool. Okay, they made more changes. We can review all of them as a group like this. I'm just going to hit keep all like a good developer that thinks a lot about these things. Let's go back into constants quick and change this once more so that I'm not hitting my cache. Not looking good. **[10:48]** You want to prove that these videos are real and not me just glazing. Here is your proof. Oh, it looks like when I accepted the changes from that other branch, they came over and they're clobbering each other. That is annoying. You know what we're going to do? We're going to stash all of those. Oh no, the cursor is probably where they're hiding the other things. So, that's a little annoying, but we can work with that. Let's try this again. **[11:21]** New agent. Paste. One last try. Still flying. See how it's running three things in parallel here? It's searching the web for the language model, the UI message change, and the open router ASDKv5 thing. It's able to do all of these at once. I don't think it needs to search for those things necessarily, but the fact that it can run multiple things in parallel is really cool. It makes even though like the TPS is faster, this change makes it feel significantly better. Oh, look, it's running the code mod this time. It's so nice having a proper full screen view for this. It **[11:51]** does feel really different. I'm so used to having like in my editor the agent thing and like expanding and collapsing it depending on what my specific needs are at a time. Now my editor can just be an editor and my agents can just be agents. And when I need to see the file it's changing. I just click the button. I can see the file that changed. And as I mentioned earlier, running npm commands is the slowest thing that I've seen this model do because it just takes a bit to run npm. I was exploring the files. I can click them and see them right here. It's just all these little things they got right feel. I tried **[12:23]** running TSC just to make sure the types were correct. I wish it would just use the editors LSP for this. God, it moves so fast. It's kind of wild. Finding more type errors. It's grinding. Look at that. Let's see if it worked this time. We'll review. Give it a quick look. Um I think Open Router's AISDK provider is newer. I wish that this was smart enough to have like access to fun little **[12:54]** editor things like you can hover over and see what the latest version is. It's 1.2.0. We'll keep that though. Fun install. Bun run index.ts skip test. Fine. But if I modify one so that it has to run it. Let's see what happens. 04 mini 3. Yeah, key is missing. Did I move? Oh yeah, I moved the Is that what this has been the whole time that I got rid of my environment file? I think that's what it **[13:28]** was. I wish I had better errors for that. That's hilarious that this was all just a user error the whole time possibly. Let me find that quick. Um, there are so many little things I need to fix with this bench. Wrong one. Constants. Aha, it's working. Look at that. Think it was just the environment variables. I'm so dumb. Cool. I got it to just upgrade this with like a lot of code that has to be changed to do it right. Missing parameters. Open AAI. Okay. What's it upset about? It got pretty **[13:59]** far. The provider returned an error. Missing required parameter. Fun. I tried. I don't want to waste too much of this video trying that out when I know it can work. More things for me to fight in the future as I try to get this project finally upgraded. But it does do other things really well, too. In particular, I've been really impressed with how well it handles user interface stuff. I did my classic build me an app that is an image generator from scratch just to see how it would look. You know what? I'll rerun it cuz it's so fast. Uh C2 make deer C2 round three. Grabbing **[14:33]** the same prompt. Still using composer. The difference here being I specified to use button because I'm tired of waiting for npm. Creates a to-do list. It's so good at to-do lists. It grinds out an X.js package JSON. And it actually seems to write them instead of just running the init command, which is interesting. But it does it correctly every time so far. It's grinding out the giant studio.x file model selector. It flies. This is all real time. Remember, I'm not speeding this up or doing anything fancy in post. You're seeing it create this whole app from **[15:04]** scratch this quickly. No lint errors found. No other errors found. Keep bun install bun rundev. And there we are. Not even that ugly looking. They screwed up the like cropping here for the G, but that's a small thing to get wrong. Looks pretty much just as good as what you'd get out of an anthropic model. Slightly worse what you get out of like GPT5 cuz it's a **[15:36]** UI god. Even for like CLI stuff I found, which has been crazy. But it's more than passable. Results are really good. It's my assumption is that they are taking data that has come from a lot of people using other models with cursor, the people who've opted in to shared their data and they use that to replicate the outputs that they get from other models that were accepted by the users. They have so much data on all of this on what responses were accepted by the developers they can use to do reinforcement learning on a model to make it really good and it shows. Let's **[16:06]** say we want it to be prettier. Let's get in andit this first because it's using work trees so it doesn't work without git. We have it inited. Now that we have this as a git repo, we can turn on work trees and multimodel. Let's try codeex composer and ha coup. The UI for this is so ugly. Rethink it. It should be minimal nice looking and dark mode. No ugly blue gradient backgrounds, please. Clean black background but with light **[16:38]** there. Yeah, I won't steer it too much. We'll leave it here. Let's see how the different models handle this. All they need is uninstall. It keeps popping up that raw thing. I think that's a bug. Pretty cool. You can just see what all the different models are doing in parallel. This is inspiring for me for T3 chat stuff in the future. Oh, they even have an open terminal in work tree option here. You can see where it's putting it. Okay, it's putting these work trees in a hidden folder in **[17:09]** the cursor directory for your user. That's a pretty clever solution to keep it from clogging up the place that you're currently located. It would be cool if I could configure that so each repo could just have these open there so I could play with them in my normal terminal. But this is fine for now. Now I can bunr run dev this and see what the composer version looks like. And honestly, that looks pretty good for a model that is that fast and cheap. I actually don't know how expensive it is compared to other models. Let me see if they show that on the cursor site dashboard. And you can see here that the amount of **[17:39]** money it costs to run composers just not too bad. A lot of my requests are less than a cent and it's all being included. But yeah, it does have prices comparable to five codecs it seems. I don't know how much that is like pushed. Yeah, it seems like they're currently pricing it at the same level of usage as GPT5 which is interesting. thing. I'm curious if the price goes up, down, or changes at all throughout. Let's see how Haiku fared with this. We'll do the same. Open terminal for this bun install, then bun **[18:10]** rundev. Here's how Haiku overhauled it. In some ways, better, in some ways worse. I don't like the way they're doing the like borders on this. It makes this section stick out more, but I do like the coloring overall. Don't like how this overflows way too far to the bottom of the page. We're still waiting for GPT5 to finish. Story of my life. GPT5. The the best model ever until you have to wait for it to be done. No lint errors. Planning next moves. Let's just see how it's doing so far. Yep. Still the best **[18:40]** looking UI. GBD5 is really good at this. But how cool is it that I can just test this this way now? It is so convenient. I didn't think I would like this feature as much as I do, but it has honestly been great. GBT5 is still going. Now, this is it summarizing the changes it made but showing the code in the summary. I don't need you to keep generating tokens to show me what you did GPT5. Well, I'll apply those. And now I've taken the changes from this version. And you can see the check mark saying like this is the one I chose and used. And now if I go to my main **[19:11]** project, bun rundev, you will see that's the one that I picked. I want to try the browser thing really quick though. So that's at browser. Make sure the image output is centered on the page. You can remove the top bar if necessary. Now it's capturing a snapshot. This is my first time seeing this. So we will allow cursor to **[19:43]** do whatever it needs to. Apparently I have to quit and reopen cursor for that. Not a good sign so far, but let's um reopen cursor quick. Let's retry this now. So now it can open the browser. It says Chrome is being controlled by automated test software. That's not the right URL. **[20:16]** I thought this would be better than it is. The page is currently available at localhost 3000. Continue and revert. There we go. Now it can actually see the page and it sees how bad the layout is. Remove the header and centering the image output. Fix the typo I introduced. Take a screenshot. Now it realized the output is weird, which it did before. But now it can actually see the result and make the change accordingly. And now if I refresh this, look at that. It did **[20:48]** it. That's actually really useful. If you find that your models are struggling to get the thing working properly in the browser, this might be a really useful solution to that problem. Like, how cool is it that it just successfully spun up a browser, fixed the UI problems, and then made the right changes when it realized the first pass was wrong? These are things that you just had to do by hand. I can't tell you how many times I've asked a model, make this change, had to go hop into the browser, take a screenshot of it being wrong, and said, no, this is what it looks like now. You screwed it up. Try again. Now it can just do that as part of its own loop. **[21:18]** That's really good. I'm super impressed with this. It has already started to impact how I'm writing code. I am more willing to try multiple models and see if the outputs work. I'm even starting to write more tests so that I can check against different models to see if the solution worked or not. I'm blown away. My team is blown away. I think this is a really good update. I'm super curious how y'all feel about this though. Am I overhyping this release or does it actually seem cool to you? Let me know what you think after you give it a shot. It's available for everyone to use today. I hope you enjoy it as much as I have.