What happens when four brilliant developers decide that waiting for your code editor to catch up with AI progress is like watching paint dry? They build their own.
Lex Fridman's podcast can get a bit lengthy - I get it. Oftentimes, I complete the podcast in snippets of 45-60 minutes per day, and therefore it usually takes me about 2-3 days to properly digest what the conversation is all about. But you don't have to wait that long. What I've attempted in this blog is to compress the conversation in a few words, and I've tried to give it a story-like vibe. Here's the original podcast
Hi, we're Roro - A full-stack product innovation studio for technology companies. Got a project in mind? Let's talk.
The Great VS Code Exodus
Picture this: It's 2021, and GitHub Copilot just dropped. Suddenly, every Vim purist on the planet is having an existential crisis. Michael, Sualeh, Arvid, and Aman - four developers who lived and breathed pure Vim - found themselves doing the unthinkable: switching to VS Code.
Why? Because Copilot felt like magic.
"It's like when you have a close friendship and your friend completes your sentences," as one of them put it. "There's a cool feeling of like, 'Holy shit, it gets me.'"
But here's the thing about magic tricks - once you know how they work, you start wondering: What if we could do this, but better?
The Scaling Laws Prophet
Enter Aman, walking around in a scaling laws T-shirt with charts and formulas on it. (Yes, this actually happened. Yes, it's exactly as nerdy as it sounds.)
In 2022, Aman made a bet that would make him look either prescient or completely delusional: AI would win a gold medal at the International Math Olympiad by 2024. His teammates thought he was crazy.
Spoiler alert: DeepMind's recent results proved he was off by exactly one point. One point.
This wasn't just lucky guessing - it was the moment the team realized that scaling laws weren't just theoretical. Bigger models weren't just incrementally better; they were predictably better. And if you could predict the improvement, you could build for the future that was coming.
Fast Is Fun (And Other Universal Truths)
"Fast is fun" became more than a motto - it became a design philosophy.
Think about why you fell in love with coding in the first place. Was it the syntax? The semicolons? The debugging sessions that lasted until 3 AM?
Probably not.
It was the insane iteration speed. The feeling that with just you and a computer, you could build something amazing, test it immediately, and make it better. In most disciplines, you're gated by resources, materials, or coordinating with other people. In coding, the only limit is how fast you can think and type.
But here's the kicker: what if typing became the bottleneck?
The Zero Entropy Revolution
The Cursor team had a realization that sounds simple but is actually profound: Most of what we type while coding is predictable.
They called it "zero entropy" - parts of coding where there are no new bits of information needed to finish your thought, but you still have to type characters to make the computer understand what you're thinking.
"Why am I doing this?" they wondered. "The model should just know."
So they built Tab - not just autocomplete, but next-action prediction.
Press Tab, and Cursor doesn't just fill in the next few characters. It:
- Completes entire code changes
- Jumps to the logical next location (18 lines down, different file, wherever)
- Shows you the next edit you probably want to make
- Eliminates every predictable keystroke between your intention and its execution
The internal competition became: "How many Tabs can we make someone press?"
The Technical Wizardry
Building this required some serious engineering gymnastics:
- Mixture of Experts models are perfect for processing huge contexts with small outputs
- Speculative decoding to make everything lightning-fast
- Aggressive caching because nobody has time to recompute everything
- Models that see your entire codebase but only generate what you actually need
The result? An AI that doesn't just complete your code - it reads your mind.
Why Microsoft Can't Just Copy This
Some folks believe that Cursor is losing the battle on First Principles, which means that if you own neither the model nor the primary data, you will lose to those who do.
Here's where it gets interesting from a business perspective. Microsoft owns GitHub, GitHub makes Copilot, and VS Code is Microsoft's baby. So why can't they just... copy Cursor's features?
Because speed of innovation matters more than resources in AI tooling. At least, this is what Cursor's founders believe.
Every few months, new AI models unlock entirely new capabilities. Being even a few months ahead makes your product "much, much, much more useful." And the team building the UI sits 18 feet away from (or is often the same person as) the team training the models.
You can't replicate that kind of tight feedback loop in a large corporation where product decisions go through multiple committees and the AI team is in a different building.
I think Microsoft has done a number of fantastic things, but I don't think they're in a great place to really keep innovating and pushing on this in the way that a startup can: Aman Sanger
The Future Is Weirder Than You Think
The Cursor team isn't just building a better code editor - they're reimagining what coding looks like when AI can predict your intentions.
Today: You think of a change → You manually implement it → You test it
Tomorrow: You think of a change → Tab → Tab → Tab → It's implemented
We're moving from "AI that helps you code" to "AI that codes while you think."
The team believes that "the Cursor a year from now will need to make the Cursor of today look obsolete." That's not marketing speak - that's what happens when you're riding the AI capability curve.
The Deeper Game
This isn't really about code editors. It's about human-AI collaboration in building complex systems.
Coding is just the beginning. The same principles - eliminating low-entropy actions, predicting next intentions, making the feedback loop between thought and execution as tight as possible - will apply to design, writing, analysis, and countless other knowledge work domains.
The teams that figure out this collaboration pattern first will have a massive advantage. Not because they're using AI as a tool, but because they're thinking in sync with AI.
The Developer's Guide to AI-Enhanced Coding
Understanding how to work effectively with AI coding tools requires a fundamental shift in thinking. Instead of viewing AI as a sophisticated autocomplete, think of it as a coding partner that learns your patterns and anticipates your needs. This mental model changes everything about how you approach development.
Starting Your AI Coding Journey
When you first start using tools like Cursor, resist the urge to jump into complex projects immediately. Begin with familiar codebases where you understand the patterns deeply. This allows you to recognize when the AI's suggestions are brilliant versus when they're subtly wrong. Think of it like learning to drive with an experienced instructor - you want to start on roads you know well.
The most effective approach is to start with repetitive tasks that have clear patterns. Refactoring similar functions, writing test cases, or implementing standard CRUD operations are perfect training grounds. These scenarios help you understand how the AI thinks and where its strengths lie.
Mastering the Collaboration Pattern
The magic happens when you learn to write code that teaches the AI what you want. This means being more intentional about variable names, function signatures, and code structure. When you write const userValidation = validateUser(userData), you're not just writing code - you're giving the AI context about what comes next.
Professional developers using AI effectively have discovered that commenting your intentions before coding dramatically improves AI suggestions. Instead of writing code and then commenting it, try writing a comment like // Validate user input and return structured error messages first. The AI uses this context to generate much more relevant suggestions.
Another crucial skill is learning to iterate in small steps. Instead of asking the AI to build an entire feature, break it down into smaller, logical chunks. Write a function signature, let the AI suggest the implementation, refine it, then move to the next piece. This approach gives you more control and produces higher-quality results.
Advanced Techniques for AI-Assisted Development
As you become more comfortable with AI coding tools, you can leverage more sophisticated patterns. Contextual priming becomes incredibly powerful - open related files, position your cursor strategically, and structure your workspace so the AI has maximum relevant context when making suggestions.
Experienced developers have found that maintaining consistent coding patterns within a project significantly improves AI performance. When your codebase follows predictable patterns for error handling, data validation, or API structure, the AI becomes much better at suggesting contextually appropriate code.
The concept of "coding in conversation" emerges as you advance. This means structuring your development process as an ongoing dialogue with the AI. You provide high-level direction through comments and function names, the AI suggests implementations, and you refine and guide the results. This creates a feedback loop that becomes increasingly effective over time.
What to Expect from Cursor's Evolution
The roadmap for tools like Cursor extends far beyond enhanced autocomplete. Multi-file editing capabilities are rapidly advancing, meaning the AI will soon understand changes that need to propagate across your entire codebase. When you modify a data structure, the AI will automatically identify and suggest updates to all dependent code, tests, and documentation.
Intelligent debugging assistance represents another frontier. Future versions will likely analyze error messages, stack traces, and code context to not just identify bugs, but suggest comprehensive fixes that address root causes rather than symptoms. This goes beyond current capabilities by understanding the broader implications of code changes.
The integration of real-time code review and optimisation suggestions will transform how we write code. Imagine an AI that continuously analyses your code for performance bottlenecks, security vulnerabilities, and maintainability issues, offering suggestions that improve code quality as you write rather than after deployment.
The Broader AI Development Landscape
Understanding where the entire AI coding ecosystem is headed helps you prepare for what's coming. Large Language Models are becoming more specialised for different programming domains. We're moving toward models that deeply understand specific frameworks, languages, and problem domains rather than being generalists.
Automated testing and validation will become far more sophisticated. Future AI tools will generate comprehensive test suites that cover edge cases human developers might miss, and they'll validate code changes against broader system requirements automatically. This shifts testing from a separate phase to an integrated part of the development process.
The emergence of AI-assisted architecture and design tools will change how we approach system design. Instead of starting with blank diagrams and documents, you'll describe system requirements and constraints, and AI will generate multiple architectural options with trade-offs clearly explained. This democratises good system design and accelerates the planning phase significantly.
Preparing for the Future of Development
The most important skill for developers to cultivate is learning to think at higher levels of abstraction. As AI handles more implementation details, your role shifts toward problem definition, system design, and quality assurance. This means developing stronger skills in understanding business requirements, designing maintainable systems, and ensuring code quality and security.
Cross-disciplinary knowledge becomes increasingly valuable. Understanding databases, networking, security, and user experience helps you provide better context to AI tools and evaluate their suggestions more effectively. The AI might generate syntactically correct code, but you need to understand whether it's the right solution for the broader system.
Developing prompt engineering skills specifically for code generation will become as important as traditional programming skills. This involves learning how to structure requests, provide context, and iterate on AI-generated solutions effectively. Think of it as a new form of technical communication.
Building AI-Native Development Habits
The most successful developers using AI tools have developed new workflow patterns that maximise the technology's benefits. Incremental development with continuous AI feedback becomes the norm—write a bit, get AI suggestions, refine, repeat. This creates a tight feedback loop that produces better results than traditional write-compile-debug cycles.
Documentation-driven development takes on new importance when working with AI. Well-documented code provides better context for AI suggestions, and AI can help maintain documentation as code evolves. This creates a positive cycle where better documentation leads to better AI assistance, which makes maintaining documentation easier.
The practice of maintaining multiple solution paths becomes more feasible with AI assistance. You can quickly explore different implementation approaches, compare their trade-offs, and choose the best solution. This leads to better architectural decisions and more robust solutions.
What This Means for Your Career
The integration of AI into development doesn't replace programming skills - it amplifies them. Domain expertise becomes more valuable, not less. Understanding your business domain, user needs, and system constraints allows you to guide AI tools effectively and evaluate their suggestions critically.
System thinking and architecture skills become increasingly important as AI handles more tactical implementation. Your ability to design systems, understand trade-offs, and ensure maintainability becomes your primary value contribution. The developers who thrive will be those who can work at the intersection of technical implementation and business value.
For those not yet in development, this represents an unprecedented opportunity to enter the field. AI tools lower the barrier to productive coding, but they don't eliminate the need for human judgment, creativity, and problem solving. Understanding how to work with AI effectively might be more valuable than traditional programming skills alone.
The Tab Revolution
The story of Cursor is really the story of a simple question: What if we stopped waiting for the future and built it ourselves?
Four developers observed that AI was improving faster than the tools were adapting. So they didn't write a plugin or start a petition. They forked VS Code and began building the editor they wanted to use.
The result isn't just a better tool - it's a glimpse into a future where the gap between intention and execution shrinks to nearly zero. That gap is just a tab away. ;)
And honestly? That future looks pretty fun.
.webp)
