Artificial intelligence is transforming software development at an unprecedented pace. Among the trailblazers is Cursor, an AI-powered code editor that has skyrocketed to $300 million in annual recurring revenue within just two years of its launch. At the helm is Michael Truell, co-founder and CEO of Anysphere, the company behind Cursor. With a decade of AI experience and a deep background in computer science and math from MIT, Michael offers a unique perspective on the future of programming and how AI will reshape the way engineers build software.

In this comprehensive article, we dive into a wide-ranging conversation with Michael, exploring Cursor’s origin story, the paradigm shift from traditional coding to “after code,” the unexpected lessons learned while building Cursor, and his vision for the evolving role of engineers in the AI era. Whether you’re an engineer, product leader, or AI enthusiast, Michael’s insights provide a fascinating roadmap for navigating the fast-approaching AI future in software development.

What Comes After Code? Michael Truell’s Vision for the Future of Programming

Michael opens with a compelling idea: “Our goal with Cursor is to invent a new type of programming, a very different way to build software.” He envisions a world “after code” — a future where engineers transition from writing verbose lines of code to specifying intent in a highly distilled, concise manner.

“More and more being an engineer will start to feel like being a logic designer and really it will be about specifying your intent for how exactly you want everything to work.”

This means moving away from the painstaking details of how software is built under the hood, toward a paradigm where the what is expressed more naturally, perhaps in a form closer to English or pseudocode. Michael contrasts two prevailing visions of AI in coding:

  1. The first is a future where software development remains largely the same — editing text in formal programming languages like TypeScript, Go, Rust, or Python.
  2. The second is a chatbot-style interface, where you simply ask an AI bot to build or modify software, akin to talking to an engineering department in Slack.

Michael believes both visions have flaws:

“The chatbot style lacks a lot of precision. If you want humans to have complete control over what the software looks like and how it works, you need to let them gesture at what they want to be changed in a form factor that’s more precise than just typing ‘change this’ in a text box removed from the whole thing.”

Similarly, the status quo of coding in text editors is insufficiently productive and accessible, especially as AI capabilities mature.

A New Representation of Software Logic

Michael imagines a future where software logic is represented in a form much closer to human-readable English or pseudocode — a “higher level” than code, easier to navigate, edit, and understand.

“You can imagine an evolution of programming languages towards pseudocode… a world where the human is still very much in the driver’s seat, having control over all aspects of the software, able to make changes very quickly with a fast feedback loop.”

This vision is profound because it suggests a shift in the fundamental interface between humans and machines — away from complex syntax and toward intuitive intent specification.

The Role of “Taste” in Software Engineering

When asked about the skills engineers will need in this “after code” world, Michael emphasizes the growing importance of taste.

“Taste will be increasingly more valuable. Often when people think of taste in software, they think about visuals — smooth animations, UI design, colors. But the other half of defining software is the logic — how the software works.”

He argues that while we have excellent tools like Figma for visual design, the logic side is still best represented by code today. However, as programming evolves, engineers will become more like logic designers, specifying what should happen rather than how.

“It will be more about the what, and less about the how exactly you do things under the hood.”

Michael also notes that current AI-assisted “vibe coding” — where AI generates large swaths of code and the human doesn’t understand the details — is a controversial and risky state of creation.

“You get to a point where you create something big enough that you can’t change it, and you lose control. Solutions to this problem involve giving makers complete control over the software even if they don’t understand the code fully.”

In essence, taste becomes the skill of having the right idea for what should be built and effortlessly translating that into software, rather than wrestling with the technical minutiae.

The Origin Story of Cursor: From Mechanical Engineering to AI Code Editor

Michael shares that Cursor’s beginnings were quite different from what it is today.

Early Exploration: Automating Mechanical Engineering

Initially, the team spent about four months working on a tool to automate and augment mechanical engineering tasks — building tools for mechanical engineers.

“There were problems from the get-go. We weren’t mechanical engineers ourselves, so there was a bit of a blind man and the elephant problem.”

They faced challenges like a lack of data on 3D models and the difficulty of adapting existing AI models for mechanical engineering.

“The way we netted it out was we needed to develop our own models from the get-go, which was tricky due to limited data and complex sourcing.”

Pivot to Programming: Seeing the Bigger Opportunity

Eventually, they realized mechanical engineering wasn’t the space they wanted to dedicate their lives to. Instead, they looked to programming, where despite existing tools like GitHub Copilot, they saw a lack of ambition and a disconnect.

“It felt like people working in the space weren’t sufficiently ambitious about where software creation was going to blow through these models.”

This realization set them on the path to building Cursor — an AI code editor with a vision for a new form of programming.

Lessons from the Pivot

Michael reflects on a common piece of advice: “Go after boring industries because there’s less competition.” Cursor’s journey proves that going after a hot, popular space — AI coding — can also work if you bring enough ambition and a unique perspective.

“Even if something looks like it’s too late or crowded, if you see a flaw or lack of ambition in existing solutions, there’s still a big opportunity.”

Why Build an IDE? The Decision to Create a New Editor from Scratch

Cursor’s approach contrasts with other companies that either build AI models alone or create AI agents that automate end-to-end programming.

Human-in-the-Loop Philosophy

Michael explains the team’s core belief: humans must remain in the driver’s seat.

“We care about giving humans control over all the decisions in the end tool they’re building. We don’t want AI making all the decisions.”

This drove them to build an IDE (Integrated Development Environment) rather than just an AI agent or a plugin to an existing editor.

The Need for a New Form Factor

Existing coding environments have very limited extensibility.

“If you think the UI and form factor of programming are going to change a lot, you need control over the entire application.”

Building their own editor allows Cursor to innovate on how programming tools work, enabling a future where programming flows through AI models but humans still maintain control.

The Future IDE: Multiple Modes and Interfaces

Michael foresees a future where programmers seamlessly move between different modes:

  • Directly coding in an IDE
  • Interacting with AI agents in Slack or issue trackers
  • Letting AI spin off tasks autonomously and then reviewing the output quickly

“You want the ability to pull in the AI’s work and work with it very quickly, then maybe have it spin off again.”

This flexible, multi-surface approach reflects the complex nature of software development workflows.

The Counterintuitive Lesson: Building Custom AI Models Despite Starting Without Them

When asked about surprises in building Cursor, Michael highlights that they did not expect to develop their own AI models initially.

The Landscape at the Start

Many companies jumped straight into training large models from scratch. Cursor’s team knew from the outset that training something like GPT-4 was out of reach.

“It felt like focusing on training your own foundation model was the wrong area because amazing models already exist.”

Instead, they focused on identifying gaps where existing models didn’t serve their needs.

Custom Models for Specialized Tasks

Today, every “magic moment” in Cursor involves a custom model in some way.

One key example is autocomplete, which requires:

  • Extremely fast responses (within 300 milliseconds)
  • Low cost per keystroke (since every keystroke triggers predictions)
  • Specialized understanding of code diffs (predicting changes across multiple files)

“We train our own models specifically for autocomplete, which no foundation model handles well.”

Other custom models help with:

  • Searching the codebase efficiently to provide relevant context to large foundation models
  • Filling in details based on high-level suggestions from bigger models

Pragmatic Use of Open and Closed Models

Cursor builds on the best pre-trained models available — often open-source ones like LLaMA — and collaborates with closed providers when needed.

“We focus on post-training and fine-tuning rather than reinventing the wheel.”

This ensemble approach, combining foundation models with specialized custom models, balances quality, speed, and cost.

Lessons on Rapid Growth: From Launch to $100M ARR in 20 Months

Cursor’s growth trajectory has been nothing short of historic, hitting $100 million ARR in under two years.

Building Quickly and Dogfooding

The first version of Cursor was hand-rolled from scratch, including building their own UI components and support for multiple languages, navigation, error tracking, and remote server connections.

“After about five weeks, we were living on the editor full-time, having thrown away our previous editor.”

They launched publicly within a few months, expecting slow growth.

Unexpected Immediate Demand

Instead, there was an immediate crush of interest and feedback, which shaped rapid iterations.

“We thought we’d be building for a couple hundred people for a long time, but the growth was fairly consistent and exponential month-over-month.”

Focus on Product Over Sales and Marketing

Michael emphasizes that the secret to their success was focus:

“We really let fires like sales and marketing burn for a long time and just worked on building a product that we and our team liked.”

Balancing Software and Model Development

Cursor exists at the intersection of a traditional software company and a foundation model company.

“We need to be excellent at building a product for millions of people, but also do more and more on the science and model side where it makes sense.”

This dual focus is challenging but critical.

Defensibility and Market Dynamics in AI Coding Tools

Michael shares his perspective on moats and competition in AI coding.

The Market is Huge with a High Ceiling

He compares the AI coding market to:

  • The search engine market in the late 1990s
  • The personal computer market in the 70s, 80s, and 90s

“The ceiling is incredibly high. You can keep getting value for incremental R&D for a very long time.”

Consumer-Like Competition vs. Enterprise Lock-In

Unlike traditional enterprise software markets that rely on lock-in and contracts, the AI coding space is more consumer-like:

“Users can try different tools and switch if they want. It’s more friendly to whoever has the most innovative product.”

Expecting Leapfrogs and Multiple Niches

Michael expects many leapfrogs in technology and product innovation.

“There will be one dominant general tool company, but also many niche players serving particular parts of the software development lifecycle.”

Reflections on GitHub Copilot and Incumbents

Microsoft’s Copilot was a major inspiration for Cursor, but Michael believes it hasn’t lived up to early expectations.

Structural Challenges for Incumbents

He suggests that the AI coding market is not friendly to incumbents because:

  • The market is not easily commoditized
  • Incumbents often bundle features with other products, limiting innovation focus
  • It’s hard to coordinate across departments to build a cohesive AI coding product

Talent Movement and Coordination

Many original Copilot team members have moved on, and coordination challenges remain.

Tips for New Cursor Users: Developing a “Taste” for AI Assistance

Michael’s advice for users centers on developing an intuitive understanding of what AI models can and cannot do.

Don’t Expect Perfect Output in One Go

“Bias less toward trying to tell the model everything at once and then accepting or rejecting the entire output.”

Instead, he recommends:

  • Breaking tasks into smaller chunks
  • Specifying incrementally and reviewing outputs frequently

Build a Gut Feeling for Model Capabilities

“Develop a taste for the quality of the model, where its gaps exist, and what it can and cannot do.”

This taste will evolve with new model releases, requiring users to continuously recalibrate their expectations.

Try Ambitious Experiments in Safe Environments

“Use side projects to push the boundaries of what AI can do without risking professional work.”

Who Benefits Most from AI Coding Tools Today?

Michael sees benefits across experience levels but notes different usage patterns.

  • Junior engineers: Tend to rely too heavily on AI for everything, which can be risky because the technology isn’t perfect yet.
  • Senior engineers: Often underestimate AI’s capabilities and stick to existing workflows.

He highlights that developer experience teams staffed by senior engineers are among the earliest adopters, helping others ramp up.

Hiring Insights: Lessons Learned Building an AI Startup

Michael shares valuable lessons from assembling the Cursor team.

Hiring Was Slower Than Ideal but Ultimately Strategic

“We actually hired too slow to begin with. We needed world-class engineers and researchers with intellectual curiosity, experimentation mindset, intellectual honesty, and bluntness.”

They focused on recruiting people who fit a culture of level-headedness and experimentation, often recruiting over multiple years.

Work-Test Projects: The Ultimate Interview

Cursor uses a two-day onsite work test where candidates build a mini-project with the team.

“It lets someone go end to end on a real project and helps us see if we want to be around this person for two days.”

This approach has scaled well and helped attract the right people.

Broadening Hiring Profiles

Early on, the team focused heavily on candidates from well-known schools with high credentials but later broadened to include excellent candidates with different backgrounds.

Staying Focused Amid Rapid AI Advancements

With AI evolving at lightning speed, how does Cursor stay focused?

Hiring the Right People

“Hiring people with the right attitude — less focused on external validation and more on building something great — is a big part of staying focused.”

Building an “Immune System” Against Hype

Michael describes developing a collective intuition for which AI advancements truly matter.

“There’s lots of chatter and hype, but only a few things really impact our business.”

He likens this to the evolution of deep learning research, where many ideas come and go, but a few elegant concepts endure.

What People Still Misunderstand About AI’s Future

Michael believes many misunderstand AI’s trajectory by focusing too much on extremes — either expecting instant transformation or dismissing it as hype.

“We’re in the middle of a technology shift that will be more consequential than the internet. It will take decades and involve many groups.”

He emphasizes the complexity of the challenge:

  • Improving models across multiple data types and modalities
  • Designing human-computer interaction experiences
  • Building domain-specific AI products that integrate the best parts of various providers

“The most successful companies will be those that build both the underlying technology and the product experience for particular areas of knowledge work.”

The Enduring Demand for Engineers in the AI Era

Despite fears that AI will replace engineers, Michael foresees continued and even increased demand.

“The physics of working on computers are so great that we should be able to do everything we want with much less friction.”

He points out how expensive and labor-intensive it is today to build even simple productivity software.

“If AI can bring down the cost and time by orders of magnitude, we’ll have tons more software and tools than ever before.”

He believes the demand for software will outstrip what we can build today, ensuring a lasting need for skilled engineers.

Final Thoughts: Building for the Future and Learning from History

Michael concludes with reflections on how to succeed in this fast-changing landscape.

“The IDE will have to change a ton going forward. Companies that ride the wave of leapfrogs and continue pushing the frontier will win.”

He advocates studying tech and business history to understand what drives innovation and longevity.

“A lot of innovation comes from studying the past — what worked and what didn’t.”

For those interested in joining Cursor’s mission, Michael encourages reaching out through their website.

Where to Find and Connect with Michael Truell and Cursor

Conclusion

Michael Truell’s journey with Cursor offers a front-row seat to the AI revolution in software development. From a bold vision of “after code” programming to the gritty realities of building custom AI models and assembling a world-class team, every detail underscores the complexity and opportunity of this moment.

Cursor’s rapid growth and innovative approach show that the future of programming will be a blend of human creativity and AI augmentation — where “taste” and logic design become the new superpowers. For engineers and product teams, the message is clear: embrace AI thoughtfully, develop a nuanced understanding of its capabilities, and prepare for a future where programming is more about intent and less about syntax.

As Michael says, this is a multi-decade transformation, and the best is yet to come.

If you enjoyed this article, consider subscribing to Lenny’s Podcast for more deep dives with industry leaders shaping the future of technology.