Why IDEs Won't Die in the Age of AI Coding: Zed Founder Nathan Sobo

The Future of Development Tools

Nathan Sobo presents a compelling argument against the "death of the IDE" narrative that's emerged with AI coding tools. Despite the impressive capabilities of terminal-based AI coding assistants, he believes visual interfaces for code remain essential.

Core Arguments Against IDE Death:

1. Source Code as Human Language - Programs are fundamentally designed for human comprehension, not just machine execution
2. Review and Context Limitations - Terminal tools show only small code excerpts, making it difficult to understand broader context
3. Visual Interface Necessity - Until AGI arrives, humans will need to interact with and understand source code

The Reality of AI Coding Tools:

• Current Capabilities: Terminal-based tools like Claude Code allow impressive English-to-code interactions
• Practical Limitations: Reviewing changes through tiny terminal excerpts becomes problematic
• Missing Context: Developers need to see how edits connect to the broader codebase

Harold Abelson's Programming Philosophy:

"Programs should be written for people to read and only incidentally for machines to execute"

This principle reinforces that source code serves as a precise language for expressing abstract processes - a language optimized for human understanding.

The Continued Need for Direct Code Interaction:

• Sometimes writing code directly remains the most efficient way to express ideas
• Defining data structures or complex logic often works better through direct coding than LLM descriptions
• Even heavy AI tool users likely run editors alongside terminal tools for inspection

Timestamp: [0:00-6:26]

The Quest for the Perfect Editor

Nathan Sobo's career-defining mission began in 2006 with a simple but ambitious goal: synthesize the best aspects of existing development tools into one unified package.

The 2006 Vision:

Inspiration from TextMate: Learned about this lightweight, fast editor through DHH's Rails demonstrations, which showed the appeal of simple, approachable tools.

The Synthesis Challenge: Existing editors each excelled in specific areas but failed to combine all desired qualities:

• Emacs & Eclipse: Powerful but complex
• JetBrains Products: Feature-rich but slow to start and sluggish
• TextMate & Vim: Responsive but limited in power
• Extensibility Trade-offs: Tools were either extensible but arcane (like Vimscript) or simple but limited

The Ultimate Editor Goals:

1. Power: Match or exceed the capabilities of the most advanced IDEs
2. Responsiveness: Achieve the speed of lightweight editors like TextMate or Vim
3. Extensibility: Provide powerful customization without arcane scripting languages
4. Synthesis: Combine all these qualities into one cohesive package

The Long-Term Commitment:

Nathan describes this as an 18-year journey of "grinding toward building the ultimate tool" - a testament to the complexity of creating development tools that truly serve programmers' needs without compromise.

Timestamp: [6:31-7:55]

Essential Insights:

1. IDEs Won't Die: Despite AI coding tools' impressive capabilities, visual interfaces for code remain essential because humans still need to understand and interact with source code
2. Source Code as Human Language: Programs are designed for human comprehension first, machine execution second - making visual tools necessary for understanding context and connections
3. 18-Year Mission: Nathan Sobo has dedicated his career since 2006 to building the perfect editor that synthesizes power, responsiveness, and extensibility in one package

Actionable Insights:

• For Developers: Even when using AI coding tools, maintain access to visual editors for reviewing and understanding code changes in context
• For Tool Builders: Focus on combining the best aspects of existing tools rather than optimizing for just one characteristic
• For the Industry: Recognize that until AGI arrives, human-code interaction through visual interfaces will remain crucial for software development

Timestamp: [0:00-7:55]

From Web Dreams to Performance Nightmares

Nathan Sobo joined GitHub as one of the first two engineers working on Atom, an ambitious attempt to create the "IDE of his dreams." The project had revolutionary goals but ultimately taught harsh lessons about architectural choices.

The Atom Vision:

1. Extreme Extensibility - Built on web technology to allow maximum customization
2. Electron Framework - Created the shell around Atom (named by Chris Wanstrath, not Nathan)
3. Web-Desktop Marriage - Combined Node.js with Chrome to create desktop apps from web pages

What Went Wrong:

• Performance Ceiling - Web browser foundation couldn't deliver the responsiveness Nathan wanted
• Extension Chaos - Open architecture allowed random extension code to destroy performance on the main thread
• Premature Promises - Team "drowned under promises" made too early in development
• Optimization Frustration - Hit walls trying to optimize using Chrome's dev tools flame graphs

The Microsoft Factor:

Microsoft copied the Atom/Electron approach, took their existing web code, and created VS Code - which went on to dominate the industry while Atom faded.

Key Realization:

By 2017, Nathan concluded that performance is not a feature you can add later - if you choose an architecture, you accept its performance limitations forever.

Timestamp: [8:01-10:48]

From Asynchronous Snapshots to Real-Time Code Conversations

Nathan Sobo challenges the industry's standard collaboration model, arguing for a more synchronous, human-centered approach to working together on code.

The Current Collaboration Problem:

• Asynchronous Email-Style - Developers work in isolation, upload snapshots, wait for web browser comments
• Delayed Feedback Loop - Hours or days between code submission and meaningful discussion
• Disconnected Experience - No real human connection or ability to interrupt and clarify

Zed's Collaboration Philosophy:

1. Real-Time Presence - Bringing teammates directly into the authoring environment
2. Figma for Developers - Multiple people working simultaneously in the actual creation tool
3. Conversational Code - Linking discussions directly to code in the editing environment
4. Zero Passenger Seat - Unlike screen sharing, everyone can actively participate

Why This Matters More Now:

• AI Collaboration - Developers are having constant conversations with AI agents in code
• Immediate Feedback - Need to give real-time feedback on AI-generated changes
• Persistent Context - Want permanent records of conversations anchored to specific code

The Git Limitation:

Traditional Git workflows break down when you need fine-grained feedback - you can't commit every token an AI agent emits and do pull request reviews on each change.

Timestamp: [10:54-14:49]

The Quest for Instant Response

Nathan Sobo's performance obsession drives Zed's architecture - when you type a key, pixels should respond on the next monitor sync with zero perceptible lag.

Performance as Foundation:

• Non-Negotiable Requirement - Performance cannot be added later; it must be built into the architecture from day one
• Monitor Sync Timing - Goal is pixels responding on the very next refresh cycle
• Web Browser Limitations - Electron/web technology fundamentally cannot achieve this level of responsiveness

Current Status:

Nathan admits they're not 100% perfect yet, but they're "hell of a lot closer than you could ever get in a web browser" - representing a significant leap from Atom's web-based constraints.

Why Performance Matters:

The difference between responsive and laggy editing isn't just comfort - it fundamentally changes how fluidly developers can think and work with their code.

Timestamp: [12:46-13:05]

Beyond Git: Tracking Every Keystroke and AI Token

Zed is developing a revolutionary approach to code collaboration that treats every edit - human or AI - as a trackable, conversational moment.

The Current Gap:

• No Git for AI Interactions - Traditional version control doesn't handle real-time AI collaboration
• Impossible Workflow - Can't commit every token an AI emits and do pull request reviews
• Lost Context - Feedback on AI changes disappears without permanent anchoring

Zed's Phase 2 Vision:

1. Keystroke-Level Tracking - Equivalent of having a commit on every keystroke or AI edit
2. Anchored Conversations - Discussions permanently linked to specific code changes
3. Streaming Edit History - Track and review every change an AI agent streams in
4. Persistent Feedback - Store and reference feedback given on AI-generated changes

Implementation Philosophy:

• Earn the Right - First build a capable standalone editor people want to use
• Work in Progress - Acknowledges this is still being developed
• Fine-Grained Control - Move beyond snapshot-based collaboration to continuous interaction

This represents a fundamental shift from Git's commit-based model to a more granular, conversation-rich approach suited for human-AI collaboration.

Timestamp: [14:49-15:59]

Essential Insights:

1. Atom's Legacy - GitHub's Atom editor pioneered Electron but hit performance ceilings, teaching Nathan that architecture choices determine permanent performance limitations
2. Collaboration Revolution - Zed challenges Git's asynchronous model with real-time, Figma-style collaboration directly in the code editor
3. AI-Ready Architecture - The shift toward human-AI collaboration makes conversational code editing more relevant than ever before

Actionable Insights:

• Performance must be architected from day one - it cannot be retrofitted later
• Real-time collaboration tools become essential as AI agents join development workflows
• Fine-grained edit tracking will replace snapshot-based version control for AI interactions

Timestamp: [8:01-15:59]

Vertically Integrated Development Experience

Nathan Sobo's approach to building Zed centers on creating a vertically integrated experience that serves as the ultimate interface between humans, source code, and AI agents.

Core Design Philosophy:

1. Complete Control: Design both UI and infrastructure from top to bottom
2. Immersive Interaction: Enable direct interaction with code alongside AI beings
3. Switzerland Approach: Position Zed as neutral ground for different AI agents to collaborate

The Interface Vision:

• Human-Centric Design: Prioritize the developer's experience and workflow
• Multi-Agent Support: Allow seamless integration with various AI coding agents
• Visual Excellence: Maintain rich visual interfaces despite terminal-based AI tool trends
• Collaborative Layer: Enable real-time interaction between humans and artificial beings

The philosophy emphasizes that while the underlying technology could be built in isolation, the real challenge lies in delivering an exceptional user experience through thoughtful vertical integration.

Timestamp: [16:04-16:30]

The Switzerland Strategy for AI Integration

Zed's Agent Client Protocol (ACP) follows the same democratization model that Microsoft pioneered with the Language Server Protocol for VS Code.

The Protocol Framework:

1. Externalized Intelligence: Move AI capabilities out of bundled IDE packages
2. Community-Driven Development: Enable different teams to build specialized agents
3. Competitive Ecosystem: Allow agents to compete and leapfrog each other
4. Domain Optimization: Support agents optimized for specific problem areas

Strategic Advantages:

• Avoid Reinventing: Focus on UI excellence rather than competing with AI labs
• Leverage Expertise: Utilize well-funded teams from Anthropic, Google, and other AI labs
• Universal Compatibility: Support any agent through standardized protocol
• Collaborative Competition: Align with industry efforts instead of competing against them

Early Success Indicators:

• JetBrains Partnership: Theoretical competitor embracing the protocol
• Growing Adoption: Multiple agent developers joining the ecosystem
• Better Than Expected: Higher resonance with the developer community than anticipated

The approach recognizes that building great AI agents requires different expertise than building performant IDEs, so Zed focuses on delivering exceptional UI for agent interaction.

Timestamp: [16:30-19:40]

Practical AI-Assisted Architecture Migration

Nathan demonstrates effective "vibe coding" through a real infrastructure migration project that showcased the sweet spot between manual coding and AI assistance.

The Challenge:

• Legacy Infrastructure: Old server-side systems needed replacement
• Time Constraints: Limited availability for hands-on implementation
• Clear Vision: Specific architectural goals but insufficient time to execute

The Vibe Coding Process:

1. Vision Description: Explained the concept to the AI agent
2. Documentation Input: Fed Cloudflare JavaScript API docs to the agent
3. Specific Requirements: Requested Rust bindings with simulator abstraction
4. Rapid Prototyping: Generated directional code in an afternoon

The Handoff Strategy:

• Transparent Communication: Clearly labeled the code as AI-generated
• Directional Guidance: Positioned it as architectural direction, not final solution
• Team Empowerment: Enabled engineers to run forward with the foundation
• Realistic Expectations: Acknowledged potential imperfections in generated code

Success Metrics:

• Time Efficiency: Achieved middle ground between full manual coding and vague documentation
• Team Velocity: Engineers successfully built upon the generated foundation
• Architectural Clarity: Provided concrete starting point for complex infrastructure changes

The experience highlights how AI coding can bridge the gap between high-level vision and implementation when used thoughtfully.

Timestamp: [19:46-21:42]

Real Usage Data from Hardcore Engineering Community

Zed's user base consists of approximately 170,000 active developers who tend to be elite, hardcore engineers with extensive coding experience.

AI Adoption Metrics:

1. Edit Prediction Usage: ~50% of users utilize autocomplete-style suggestions
2. Agentic Editing Adoption: ~25% of active users engage with full agentic workflows
3. Measurement Challenges: Open-source nature allows easy opt-out, making perfect metrics difficult

User Behavior Patterns:

• Programmer-Driven: Edit predictions keep developers in the driver's seat
• Selective Adoption: Users choose features based on their workflow needs
• Professional Focus: Hardcore audience attracts more serious, professional developers

Community Response to AI Integration:

• Mixed Reception: Some initial resistance from traditionalist users
• Forward-Looking Philosophy: Leadership committed to embracing AI advancement
• Natural Selection: Users who oppose AI innovation may migrate to other tools
• Professional Attraction: AI capabilities draw more professional developers to the platform

Leadership Perspective:

Nathan emphasizes moving toward the future rather than clinging to tradition, accepting that some users may leave while attracting others who embrace AI-assisted development.

The data suggests that even among elite developers, AI adoption is significant but not universal, with different comfort levels for various types of AI assistance.

Timestamp: [22:22-23:59]

Essential Insights:

1. Vertical Integration Strategy - Zed's success comes from controlling the entire stack from UI to infrastructure, enabling immersive human-AI collaboration experiences
2. Switzerland Positioning - The Agent Client Protocol democratizes AI coding by making Zed neutral ground for different AI agents, similar to how Language Server Protocol revolutionized VS Code
3. Practical AI Implementation - Effective "vibe coding" requires clear vision, transparent communication, and realistic expectations about AI-generated code quality

Actionable Insights:

• 50% adoption rate for edit prediction features among Zed's 170,000 elite developers shows significant but not universal AI acceptance
• Cloudflare migration example demonstrates how AI can bridge the gap between high-level architectural vision and implementation
• JetBrains partnership proves that even competitors can collaborate when protocols benefit the entire ecosystem

Timestamp: [16:04-23:59]

Performance-Driven Developer Experience

Zed attracts seasoned developers who prioritize the tactile experience of their development tools. As Nathan Sobo explains, when you use a tool 40 hours a day, performance issues like dropped frames or lag become genuinely bothersome.

Key Performance Advantages:

1. Extreme Performance Focus - Zed delivers the same features as competitors but with significantly better performance
2. GPU-Accelerated Rendering - The entire application uses shaders running on the GPU to render the UI, similar to video game rendering techniques
3. Responsive User Experience - Tools that can keep up with developers' hands and thought processes

Target Audience Evolution:

• Current Users: Experienced developers who care about well-crafted, fast tools
• Future Vision: Plans to appeal to broader audiences, including casual users like a dentist coding software for her practice
• Growing Appreciation: As developers become more seasoned, they increasingly value the tactile quality of their development environment

Technical Implementation:

The entire Zed application is organized around delivering data to GPU shaders that render the UI using techniques borrowed from video game development, specifically 2D UI rendering with 3D world rendering methods.

Timestamp: [24:05-25:13]

Balanced Perspective on AI Coding Tools

Nathan takes a more nuanced stance than his engineer Conrad's viral "Why LLMs Can't Build Software" article, acknowledging both the strengths and limitations of current AI coding tools.

Where LLMs Excel:

1. Knowledge Extraction - Acting as a "knowledge extruder" for well-documented, standard practices
2. GPU Programming - Generating rendering pipelines and GPU configuration code that would typically require extensive Stack Overflow searches
3. Rust Procedural Macros - Creating complex code generation tools, like integrating Tailwind CSS concepts into Rust graphics frameworks
4. In-Distribution Tasks - Performing exceptionally well when the task matches their training data

Current Limitations:

• Complex Problem Solving - Struggle with novel problems requiring simultaneous constraint satisfaction
• Architectural Thinking - Less helpful when the challenge is conceptual rather than implementation-focused
• Out-of-Distribution Work - Performance drops significantly for unique or unprecedented coding challenges

Practical Usage Patterns:

Nathan still uses LLMs regularly but strategically:

• Exploration Tool - Generating code to quickly explore ideas, even if never intended to run
• Rapid Prototyping - Creating throwaway implementations to test concepts
• Context-Dependent Application - Choosing when to use AI based on the specific nature of the coding task

Timestamp: [25:13-30:37]

Speed vs Intelligence Trade-offs

Nathan emphasizes the importance of AI model speed in development workflows, highlighting the need for tools that can generate code diffs on demand without sacrificing too much intelligence.

Key Requirements for AI Speed:

1. On-Demand Diff Generation - Ability to quickly conjure code changes when needed
2. Intelligent Model Switching - Tool builders need to determine when to use faster vs smarter models
3. Real-Time Interaction - Fast enough to support interactive development workflows

Current Challenges:

• Watching vs Working - Developers face the choice between monitoring AI progress or stepping away
• Unwanted Behavior - AI sometimes writes unnecessary tests or goes off-track from the intended task
• Interruption Needs - Developers need the ability to stop AI when it's heading in the wrong direction

Future Vision:

Nathan sees potential in models like Haiku that prioritize speed, but acknowledges that tool builders must solve the orchestration challenge of when to deploy different model capabilities for optimal developer experience.

Timestamp: [31:06-31:57]

Essential Insights:

1. Performance Matters to Experienced Developers - Seasoned developers gravitate toward Zed because they value responsive, well-crafted tools that don't drop frames or lag during intensive use
2. LLMs Excel at Knowledge Extraction - AI coding tools work best as "knowledge extruders" for well-documented, standard practices rather than novel problem-solving
3. Speed vs Intelligence Balance - The future of AI coding tools depends on finding the right balance between model speed and intelligence for real-time development workflows

Actionable Insights:

• Target experienced developers first with performance-focused tools, then expand to broader audiences
• Use LLMs strategically for in-distribution tasks like GPU programming and macro generation
• Prioritize AI model speed for interactive development experiences while maintaining sufficient intelligence

Timestamp: [24:05-31:57]

Future IDE Architecture for AI Collaboration

Nathan Sobo envisions Zed transforming into a fundamentally collaborative environment designed for multiple humans and AI agents working together simultaneously.

Core Evolution Areas:

1. Multi-Agent Conversation Management

• Handle multiple conversations with different agents across various projects
• Enable seamless switching between agent interactions
• Support parallel workflows when LLMs require processing time

2. Human-Agent Collaboration Bridge

• Pull other humans into ongoing agent conversations
• Use agent discussions as background context for team collaboration
• Create fast-track methods for loading relevant code and problems

3. Persistent Code Context System

• Maintain stable references to code locations over time
• Build continuous representation of code evolution beyond snapshot-based systems
• Enable LLMs to access complete conversation history tied to specific code sections

Revolutionary Interface Concepts:

• Conversation-Centric Design: Moving beyond traditional tree-left, tabs-middle, panels-right layout
• Document-Chat Hybrid: Treating conversations as evolving documents rather than simple chat logs
• Interactive Code Rendering: Making code snippets within conversations directly editable and synchronized
• Multibuffer Integration: Combining code pieces from across the codebase into single editable interfaces

Timestamp: [32:51-36:46]

Beyond Simple Chat: Document-Based AI Interactions

Zed is reimagining AI conversations as dynamic, interactive documents rather than linear chat experiences, creating a new paradigm for code collaboration.

Document-Conversation Hybrid Model:

1. Evolving Document Structure

• Conversations function as living documents that develop over time
• References from different codebase locations get injected dynamically
• Edits and changes unroll as a comprehensive log

2. Interactive Editing Surface

• Move cursor throughout previous conversation history
• Edit code directly within conversation context
• Synchronize changes with actual file locations in real-time

3. Enhanced Code Integration

• Expand context like GitHub pull requests
• Edit fresh code snippets directly in conversation
• Navigate between conversation points to review specific changes

Keyboard-First Navigation:

• Vim-Style Interaction: Full keyboard navigation through conversation history
• Editor-Like Experience: Treat conversations as a new type of editor interface
• Direct Code Manipulation: Reach out and interact with code pieces embedded in discussions

Technical Innovation:

• Multibuffer Technology: Combines code fragments from across codebase into single editable interface
• Contextual Selection: Review changes that occurred between any two conversation points
• Unified Editing Experience: Seamless interaction between conversation and code editing

Timestamp: [37:04-39:23]

The Performance Perfectionist's Dilemma with AI Speed

Despite recognizing AI's potential, Nathan struggles with the inherent latency that conflicts with his obsession for instantaneous feedback.

Core Frustration Points:

1. Waiting Time Issues

• All current AI tools require waiting periods that disrupt flow
• Conflicts with his engineering philosophy of keystroke-level responsiveness
• Built Zed specifically for next-frame feedback on every keystroke

2. Context Switching Problems

• Forced to handle other tasks while AI processes requests
• Disrupts focused development workflow
• Creates mental overhead managing multiple concurrent activities

3. Quality vs. Speed Trade-off

• Current AI tools produce results that need significant refinement
• Time spent waiting plus correction time often exceeds manual coding
• Uncertainty about when AI will reach the "tenth of the time" threshold

The Tipping Point Vision:

Potential Game Changer: If AI could deliver "almost correct" results in a tenth of the current time, it might fundamentally shift the development paradigm.

Current Status:

• Jury Still Out: Nathan remains uncertain about AI's ultimate trajectory
• Performance First: Maintains focus on instantaneous feedback as core requirement
• Cautious Optimism: Recognizes potential but demands speed improvements

Timestamp: [32:05-32:45]

Transforming Code from Static Text to Rich Information Hub

Nathan envisions code evolving from simple text files into comprehensive metadata repositories that capture the complete context and history of development decisions.

Current Limitations:

1. Metadata Poverty

• Code files contain minimal contextual information
• Comments provide limited insight into decision-making
• GitHub snapshots offer only punctuated, disconnected views

2. Context Loss

• Conversations about code happen in separate tools
• Decision rationale gets lost over time
• No stable way to reference evolving code locations

Revolutionary Metadata System:

1. Persistent Code References

• Stable addressing system for code locations across changes
• Continuous representation of code evolution vs. snapshot-based systems
• Permanent anchoring of conversations to specific code sections

2. Comprehensive Context Capture

• All conversations tied directly to relevant code sections
• LLMs can query: "What discussions happened behind this code?"
• Rich historical context accessible for future development

3. Collaborative Memory System

• Remember everything related to code development
• Enable deep context mining for AI agents
• Create searchable knowledge base anchored to actual code

Technical Implementation:

• Backbone Architecture: Code serves as the central structure for hanging all related data
• Continuous Tracking: Moving beyond git's discrete commit model
• Contextual Conversations: Discussions become permanent, searchable code annotations

Timestamp: [34:03-34:57]

Essential Insights:

1. AI Speed Bottleneck - Current AI tools frustrate performance-obsessed developers due to waiting times that disrupt keystroke-level feedback workflows
2. Collaborative IDE Evolution - Future IDEs will become fundamentally collaborative environments supporting multiple humans and AI agents simultaneously
3. Code as Metadata Backbone - Code will transform from static text into rich information repositories with persistent references and comprehensive conversation history

Actionable Insights:

• Conversation-Document Hybrid: AI interactions should function as evolving documents rather than linear chats, enabling direct code editing within conversation context
• Multibuffer Innovation: Combining code fragments from across codebases into single editable interfaces creates new possibilities for agent collaboration
• Persistent Context System: Building stable code references and continuous evolution tracking enables LLMs to access complete development history and decision rationale

Timestamp: [32:05-39:40]