Cursor CEO Michael Truell: Chat-Based AI Coding Is a False Premise
> Source: Cursor CEO Michael Truell, a16z Podcast > Core claim: The future of programming is not "chat-generating code" but "the world after code" — software logic evolving toward pseudocode and English, with humans editing intent at a high level and AI implementing it underneath in real time.
---
Two Competing Illusions
The industry currently holds two mutually exclusive illusions about how software will be built in the future.
The conservative illusion: Everything stays the same. TypeScript, Go, and Rust still need to be hand-written; AI is just a smarter autocomplete. Believers hold that programming is a craft, and crafts don't disappear.
The radical illusion: Writing software will be like chatting with an outsourced team in a group chat. You state requirements, AI generates results like a blind box. If something's off, you add another sentence and AI takes another pass — until you sigh and say, "Good enough."
Cursor CEO Michael Truell said in a recent a16z interview that both views miss the mark.
Especially the second one — chat-based coding simply doesn't work.
---
Why Chat-Based Coding Is a False Premise
Truell offers one reason, and it's fatal: lack of precision.
Imagine telling an outsourced engineer in Slack: "Change this button in my app."
The problem isn't insufficient information — it's that intent cannot be conveyed precisely. What should change about the button? Color? Size? Position? Click behavior? Responsive layout adaptation?
In real software engineering, a single button may involve:
- Responsive rules across three breakpoints
- Style mappings for five states
- Error handling for two API calls
- Traffic allocation for one A/B test
- Half a dozen accessibility (a11y) attributes
- Looks like English, reads like a product doc
- But every word has precise semantics and executable boundaries
- No pointers, no memory management, no type gymnastics
- Yet free of natural language's ambiguity — it's structured, verifiable, and rollback-able
- Chat mode: You say "change this," the AI guesses your meaning, generates a pile of code, you copy-paste
- "After code" mode: You "point at" a specific location and give a precise adjustment; AI implements it underneath, but you always know what every line is doing
- Punch cards: You personally wired the correct connections
- Assembly: You replaced machine code with mnemonics
- C: You no longer worried about register allocation
- Python: You no longer worried about memory management
- AI era: You no longer worry about implementation details
- Good retreats: You still control the logical structure; you just don't hand-write every line of implementation
- Bad retreats: You give up understanding the logical structure and hand everything to the AI "black box"
- Abstraction: hide details, expose interfaces
- Type systems: let the compiler check consistency
- Tests: let machines verify behavior
- Version control: let us roll back to any historical state
- A type system never "sort of" thinks your code is correct
- A test never "approximately" passes
- Git never "roughly" rolls back to a version
- Understand system architecture and boundaries
- Design contracts between modules
- Define precise semantics for state and behavior
- Review whether AI-generated implementations match intent
- Locate root causes at the logic level when system behavior deviates
- a16z Podcast: Michael Truell — How Cursor Builds at the Speed of AI
- Cursor: https://cursor.com
- Michael Truell on X: https://x.com/mntruell
You cannot express all of this in one sentence of natural language. Even writing a long prompt just means clumsily describing in English logic that could have been precisely expressed in code.
Truell puts it more bluntly:
> If you want full control over software, you can't just say "change this part of my app" from a chat box floating outside the system. You must be able to "point at" specific places and make extremely precise, surgical adjustments.
This isn't a knock on natural language. It's that natural language is good at describing "what," not "how." And most of software engineering's effort goes into the "how."
Chat conversations always exist outside the system. After a hundred rounds of chatting with AI, you may not understand the generated code at all. When something breaks, you can't return to any moment in those hundred rounds — you can only start a new conversation and hope the AI guesses your intent this time.
That isn't programming. That's a guessing game played in natural language.
---
What "The World After Code" Looks Like
Truell has a name for it: a world after code.
Not "no code," but "after code" — code recedes beyond human view and becomes machine-to-machine whisper. What humans face is an extremely readable, extremely precise logic document.
Think of it as "super pseudocode":
You stand at this document's high dimension and edit logic directly. AI translates it into executable implementations underneath in real time.
This isn't science fiction. Truell has already started building it in Cursor.
Cursor's Composer feature is a first step in this direction: you write a descriptive piece of logic in the editor, and instead of generating code and handing it to you, Cursor understands your intent, finds the places to change in the codebase, and executes modifications precisely and atomically.
The difference:
---
Programming History Is a History of "De-Symbolization"
Truell observes that from punch cards to assembly, from C to Python, humans have been stepping back:
Each "step back" leaves intent to humans and details to machines.
But a key distinction:
Truell is wary of the latter. He has repeatedly criticized "vibe coding" — the "if it runs, ship it, no matter how it works" approach.
> AI should accelerate good engineering practices, not eliminate them.
---
Why Precision Is the Only Way Out
The core tension in software engineering has never been "writing code" vs. "not writing code."
It has always been: how to maintain understanding and control of a system while complexity explodes.
A mid-sized backend service may have tens of thousands of lines, dozens of modules, and a dozen state transitions. Human working memory is limited — we can't hold every detail of the entire system in mind at once.
So we invented:
The common trait of these tools: they are all precise.
Precision is the only way humans control complex systems.
Chat-based programming's problem is precisely that it abandons precision. You describe requirements in natural language; AI generates implementations from a probabilistic model. In this process there's no compiler checking, no type system constraining, no tests verifying. Only "rapport" between you and the AI.
That isn't engineering. That's luck.
---
What Cursor Is Doing
Truell doesn't stop at theory. Cursor's product evolution steps steadily toward "the world after code."
Step 1: Tab completion AI guesses your next line; you press Tab to accept. This is "AI-assisted hand-writing" — precision guaranteed by the human who reviews the code before accepting.
Step 2: Cmd+K edits You select code, describe the change, and AI modifies it in place. You still see the diff and can review line by line.
Step 3: Composer You describe a feature; AI coordinates changes across multiple files and produces a complete implementation plan. But you can still review every change, roll back, and fine-tune.
Step 4: Agent (in progress) AI doesn't just execute commands — it understands your intent and autonomously navigates, plans, and executes in the codebase. Crucially, everything it does is visible, understandable, and interruptible by you.
Truell stresses repeatedly: Cursor isn't building "AI writing code for programmers" — it's building "AI freeing programmers from implementation details so they focus on logic and architecture."
---
Will Programmers Still Be Needed?
Yes. But the definition of "programmer" will change.
Future software engineers may not write a single line of TypeScript or Rust. But they will need to:
In other words, engineering thinking won't disappear; coding skills will atrophy.
Just as today's programmers don't need assembly but still need to understand CPU caches, memory models, and concurrency semantics, future programmers won't hand-write every line of business code but will still need to understand distributed systems, consistency models, and security boundaries.
---
Conclusion
What Michael Truell is really doing is redefining the boundary of AI-human collaboration:
> Not "humans give requirements, AI generates blind boxes." Nor "humans hand-write every line." Rather: "humans precisely define intent at a high dimension; AI precisely implements it underneath."
The key to this boundary is precision.
Natural language is ambiguous; code is precise. AI-era programming is not about replacing precise code with ambiguous language, but about finding an expression more powerful than code that remains precise.
Maybe it looks like pseudocode. Maybe structured English. Maybe an executable, verifiable, rollback-able product requirements document.
That is "the world after code."
Code isn't dead. Code has gone invisible.
---