Building software is hard. But what if the very act of coding could be replaced by something better—something that lets you simply describe what you want, and it gets built? In this in-depth conversation, Michael Truell, co-founder and CEO of Anysphere, the company behind Cursor, reveals the ambitious vision driving one of the fastest-growing startups in AI-powered coding. From early pivots and lessons learned to the deep challenges of building superintelligent AI agents, he shares a compelling perspective on the future of programming and the irreplaceable human element of taste.

In this article, you’ll dive into the origins of Cursor, the evolution of AI-assisted coding, and the critical bottlenecks that remain before AI can truly replace human programmers. You’ll also get an inside look at how Cursor’s team approaches product development, hiring, and the quest to build a tool that could revolutionize software creation over the next decade.

Inventing a New Type of Programming: Beyond Code as We Know It

Michael Truell opens the conversation by stating the company’s ambitious mission:

“For us, the end goal is to replace coding with something much better.”

He explains that the team behind Cursor—himself and three co-founders—are programmers at heart, attracted to coding because it allows you to build things quickly, to do things that are simple to describe. Yet traditional coding requires laborious editing of millions of lines in esoteric formal languages just to make simple ideas show up on a screen.

The vision for Cursor is to invent a new way to build software that is higher-level and more productive. Instead of writing lines of code, you would define how you want the software to work and look, and the system would build it for you.

“Over the next 5 to 10 years it will be possible to invent a new way to build software that’s higher level and more productive, that’s just still down to defining how you want the software to work and how you want the software to look.”

Cursor’s approach is evolutionary: at any point, it aims to be the best way to code with AI, then to evolve that process away from normal programming to something very different.

Are We There Yet? The Current State of AI-Assisted Coding

When asked if we are already at the point where you just describe what you want and it gets built, Michael offers a nuanced view:

“I think you guys are probably on the forefront of it with YC because in smaller code bases with smaller groups of people working on a piece of software, that’s where you feel the change the most.”

He notes that in professional software development—where millions of lines of code and dozens or hundreds of people are involved over many years—the idea of “vibe coding” (coding without really looking at or understanding the code) doesn’t really work. The complexity and nth-order effects mean you can’t just avoid thinking about the code.

Currently, AI is most effective as a productivity tool helping programmers read, write, and understand code. Within Cursor, AI writes about 40-50% of the lines of code produced, but users still need to review everything.

Michael sees an important chasm ahead:

“An important chasm for us to cross as a product will be getting to a place where we become less of a productivity tool that’s helping you look at, read, write, understand code and where the artifact kind of changes.”

He believes that professional developers are still some ways from fully leaning on AI agents to write code end-to-end without human oversight.

Two Ways to View Large Language Models (LLMs)

Michael explains two perspectives on LLMs:

  1. Human-like Helper: You interface with them like a human assistant, asking questions and delegating tasks.
  2. Advanced Compiler or Interpreter: They are a new kind of programming technology that helps translate ideas into software.

He emphasizes that one of the product challenges is maintaining fine-grained control:

“You should always be able to move something a few pixels over. You should always be able to edit something very specific about the logic.”

The future, he suggests, might involve evolving programming languages to be higher-level or enabling direct manipulation of the UI—pointing at elements on the screen and making changes visually.

The Bottlenecks to Superhuman AI Agents in Coding

Michael dives deep into the technical and practical bottlenecks that prevent AI agents from fully replacing human programmers today.

Context Window and Scale Limitations

One major limitation is the context window size of current models:

“If you have 10 million lines of code, that’s maybe 100 million tokens. Having a model that can ingest that, have it be cost-effective, and pay attention effectively to that context window is tricky.”

Even with recent advances enabling models to handle millions of tokens, this is still a huge challenge. Moreover, continual learning—where a model remembers the context of an organization, past attempts, and collaborators—is an unsolved problem.

Michael notes:

“Continual learning and long context is definitely a bottleneck to being superhuman.”

Long Time Horizon Tasks and Forward Progress

Another challenge is the ability to do tasks over very long time horizons and continue making forward progress without losing track.

He references a chart showing that the maximum length of time an AI can make forward progress on a task has increased from seconds to about an hour in recent models. This is an impressive gain but still limited compared to human engineers.

Multimodal and Interactive Coding

Software engineering involves running code, inspecting logs, and interacting with various tools. AI agents will need to interface with these modalities to be truly effective.

“Being able to run the code, being able to look at Datadog logs and interface with those tools that humans use… there are a lot of known devils and unknown devils that we will have to face.”

The UI Challenge: Taste and Precision

Even if an AI agent could code better than any human, the UI for specifying changes is imprecise:

“The UI of just having a text box asking for a change of the software is imprecise. So even in the limit if you care about humans being able to control what shows up on the screen, you’ll need a different way for them to interface.”

This might include higher-level programming languages or direct manipulation interfaces.

Michael also highlights an intriguing insight about AI’s current aesthetic sense:

“The models don’t seem to have a really clear sense for aesthetics… this human-level designer needs to actually be able to see.”

Training models to improve at aesthetics is done through reinforcement learning on human feedback, a costly and data-intensive process that is a workaround for the continual learning problem.

Why Taste Will Always Matter in Software Engineering

Despite AI’s growing capabilities, Michael believes one thing will remain irreplaceable:

“One thing that will be irreplaceable is taste. So just defining what you actually want to build.”

Taste applies not only to the visual aspects of software but also to the logic and how the software works.

“Right now the act of programming kind of bundles up you figuring out how exactly you want the thing to work… and the kind of high-level taste of the implementation details.”

Currently, programmers act as “human compilers,” translating their high-level intent into detailed instructions.

Michael predicts:

“More and more of that human compilation step will go away, and computers will be able to fill in the gaps.”

Yet the taste for what is useful and what to build will never disappear.

He quotes a sentiment that captures this beautifully:

“People will help you hit this bar, but the truly great, the truly masterful, they hit a bar that you can’t even see.”

This “taste” is what makes a great engineer a “logic designer,” someone who defines the intent and vision behind the software.

The Implications of AI-Driven Programming for Builders and Niche Software

Michael foresees profound changes in the software industry:

  • Massive Productivity Gains: Professional developers will become orders of magnitude more productive. He reflects on how slow large software projects move today and how AI could accelerate that dramatically.

  • Explosion of Niche Software: More niche software products will exist because AI will make building them much faster and cheaper.

He shares a personal anecdote from his early career:

“One of my first jobs was working for a biotech company staffed by wet lab scientists developing drugs. They needed a ton of internal software development to manage experiments… and the existing off-the-shelf tools were really bad.”

Such companies had to hire and train software engineers for internal tools, a costly process.

Michael believes:

“There will just be many more options available to companies like that.”

The “physics of digital space” are already great, and AI will turn them up many notches.

The Early Days of Cursor: From CAD to Code

Michael recounts how Cursor’s founding team met at MIT and shared a youthful ambition to build something big.

Their early work focused on AI-assisted mechanical engineering, specifically:

“We worked on a co-pilot for computer-aided design, training autocomplete models to help people predict next changes to 3D models in tools like SolidWorks or Fusion 360.”

This was a challenging problem due to the complexity of CAD kernels and the scarcity of data compared to code.

They did extensive user interviews with CAD users and machinists but realized:

“We really weren’t as excited about mechanical engineering as we were about coding. Also, the science back then wasn’t ready for 3D.”

Additionally, the pre-trained models and data availability were insufficient.

Training Large Models and Infrastructure Challenges

During this time, they gained valuable experience training large models with tens of billions of parameters, including for behavior cloning.

Michael shares:

“Training large language models at that scale was not something a lot of people were doing back then.”

They also worked on inference infrastructure, which proved immensely useful later for Cursor, which now handles over half a billion model calls per day.

The Pivot from CAD to Coding

Although they initially pursued the CAD idea, they recognized the need to pivot:

“We had a little bit of trepidation about going into the coding space because there were so many people already doing it.”

They were inspired by GitHub Copilot’s success and saw the ceiling for AI-assisted coding as very high.

Michael explains:

“We felt that in 5 years all coding was going to flow through these models and active programming was going to entirely change.”

They also believed existing players were not aiming for a completely new type of coding.

This pivot was not a straight line but a realization that their passion and opportunity lay in reinventing coding itself.

Following the Scaling Laws and Building the Product

Michael recounts how they closely followed the scaling laws of AI models, knowing that improvements in data and compute would keep pushing capabilities higher.

They made a key, non-obvious product decision early on:

“We decided not to build an extension but a full editor. That was not obvious to people at the time.”

This decision was influenced by inside knowledge of GitHub Copilot’s development, which required changes to VS Code’s mainline editor to support features like ghost text autocomplete.

Michael shares the story of GitHub Copilot’s development:

“They spent almost a year wandering in the desert experimenting with different product ideas before hitting on autocomplete.”

He notes that building a full editor gave them more control and flexibility, even though it attracted criticism.

From Launch to Product-Market Fit and Growth

Cursor’s first public beta took about 3 months from lines of code to release, followed by about a year of iterative refinement with small user numbers.

Only after building custom models and improving the product did growth take off.

Michael describes the feeling:

“We sort of have a tiger by the tail now, but there are still many things to execute on.”

They also had to break traditional “iron laws” around hiring and growth, scaling headcount rapidly to keep up with product demands.

Metrics That Mattered: Paid Power Users and Retention

Instead of focusing on DAUs or MAUs, Cursor tracked:

“Are you using the AI four or five days a week out of seven?”

They cared about paid power users because Cursor serves professionals and delivering the tool has real costs.

Michael warns against optimizing for demos:

“With AI, it’s easy to put together a video that looks revolutionary but the real work is dialing in speed, reliability, intelligence, and product experience.”

They emphasized dogfooding and usable internal demos to stay on the right path.

The First 10 Hires: Building Talent Density and Culture

Michael stresses the importance of hiring slowly and carefully at the start:

“If you really nail the first 10 people, they accelerate the company and set a high talent bar.”

These early hires act as an immune system, keeping the bar high and culture strong.

Cursor’s early team members were product-minded polymaths who could work across models, software, and product.

Evaluating Engineers in the Age of AI

With AI tools becoming ubiquitous, Michael explains how Cursor evaluates engineers:

“We still do first technical screens without allowing AI other than autocomplete.”

Programming without AI remains a great timeboxed test of skill and intelligence.

They also hire fantastic programmers without AI experience and train them on the job, benefiting from the “beginner’s mind” insights they bring.

Keeping Hacker Energy Alive at a $9 Billion Valuation Company

Despite rapid growth, Michael still writes code and prioritizes hiring passionate people.

Cursor’s last step in hiring is a two-day onsite where candidates work on a project with the team and demo it, allowing the company to assess energy and passion.

He emphasizes balancing top-down alignment with bottoms-up experimentation, encouraging engineers to take time for side projects and innovation.

The Moats and Durability of AI Coding Tools

Michael compares the market to enterprise software and search in the late 90s:

“The product ceiling is really high, and distribution is really helpful for making the product better.”

Like search engines learn from clicks and bounces, Cursor learns where users accept, reject, and correct AI suggestions to improve models and product.

He also draws inspiration from consumer electronics:

“The ChatGPT moment is like the iPod or iPhone moment of our age.”

He believes there are several “big moments” yet to come in AI-assisted coding and software building.

Looking Ahead: A Decade of Magnified Building Ability

Michael closes with an inspiring vision:

“This is going to be a decade where your ability to build will be so magnified, both for people who already build for a living and for tons more people.”

He celebrates the accessibility and creativity this revolution will unlock.

“What a time to be alive.”

This comprehensive conversation with Michael Truell reveals not just the technical challenges and product decisions behind Cursor, but also the deep philosophy guiding the company’s mission to reinvent programming. From the importance of taste and human intent to the bottlenecks of AI agents and the future of software creation, this interview offers a masterclass in building the future of code.

As AI continues to evolve, the decade ahead promises to transform how we build software, making it faster, more creative, and accessible to many more people than ever before. Cursor stands at the forefront of this transformation, racing toward a future where coding as we know it is replaced by something far better.

For anyone interested in AI, software engineering, or the future of technology, Michael’s insights provide invaluable context and inspiration for what lies ahead.