The space between the Commits with Zed and DeltaDB's Nathan Sobo

The podcast explores the increasing standardization of technology, highlighting how tools like browsers (e.g., Chromium) and code editors (e.g., Visual Studio Code) have consolidated dominance, reducing historical diversity (e.g., 1015 browser options 20 years ago). It critiques the reliance on Electron-based web apps for code editing, arguing that they often lack efficiency and user experience for intensive tasks, prompting the creation of ZEDa new editor built from scratch to address these gaps. The discussion emphasizes the tension between market-leading tools and niche innovations, drawing parallels to historical technology battles (e.g., VHS vs. Betamax), while advocating for personal-driven approaches to tool development that prioritize workflow efficiency over mainstream adoption.

A major focus is Delta DB, a next-generation version control system designed to track not just code snapshots but also the entire development process, including intermediate edits, conversations, and agent interactions ("dark matter"). Unlike Git, which captures discrete commits, Delta DB uses a character-level tracking system and directed acyclic graphs (DAGs) to model changes, enabling real-time collaboration, shared work trees, and seamless navigation through code history. It aims to enhance transparency and accountability by linking code changes to the reasoning and discussions behind them, while addressing privacy concerns through selective sharing controls. The system also introduces lightweight, continuous versioning (waypoints) and conflict-free collaboration via CRDTs, positioning it as a potential evolution of Git with broader, more fluid workflows for team and individual developers.

• What if you decided to build a native code editor to escape Electrons performance limitations?

  • Move: Start prototyping a code editor using a lightweight, native framework (e.g., Rust with Tokio or Go) instead of Electron, prioritizing low memory overhead and real-time responsiveness for heavy IDE tasks.
  • Why Now?: Electron-based tools like VS Code dominate but suffer from high RAM usage and lag in extended sessions, leaving a gap for developers who prioritize efficiency.
  • Expected Upside: A faster, more capable editor could attract users frustrated with bloated Electron tools, establishing a niche in the market and offering personal satisfaction through engineering rigor.

• What if you integrated Delta DBs continuous versioning into a collaborative coding tool?

  • Move: Develop a plugin or standalone app that tracks every keystroke and conversation (e.g., AI agent prompts) as versioned deltas within a project, enabling real-time collaboration and time-travel debugging.
  • Why Now?: Current tools (GitHub Copilot, VS Code) fragment collaboration into post-snapshot artifacts, while Delta DBs model offers a unique, frictionless way to capture and share development context.
  • Expected Upside: A tool that bridges code and collaboration could solve problems like lost context or fragmented team workflows, positioning you as a pioneer in next-gen version control.

• What if you launched a tool tailored to your niche workflow but designed for broader adoption?

  • Move: Build a code editor or IDE focused on a specific use case (e.g., AI-assisted debugging, low-latency terminal integration) but design its core to be extensible via plugins or modular components.
  • Why Now?: The market is saturated with generalist tools, but developers crave specialized, high-quality solutions. Starting with a deeply personal need gives you a strong foundation for iteration.
  • Expected Upside: A product born from solving your own pain points could gain traction with others facing similar challenges, creating a community-driven adoption loop.

• Build custom tooling tailored to your workflow
  Create a code editor or development tool that addresses your specific pain points (e.g., ZEDs focus on efficiency and native performance) instead of relying on market-dominant but inefficient solutions like Electron-based IDEs.

• Avoid Electron-based apps for heavy IDE use
  Prioritize native applications over web-based IDEs (e.g., VS Code) for extended development work due to their poor memory efficiency and user experience limitations, as highlighted by the critique of Chromium-based frameworks.

• Adopt continuous versioning for collaboration
  Implement systems like Delta DB to version not just code snapshots but also the entire development process (e.g., intermediate edits, AI prompts, and conversations), enabling real-time collaboration and context sharing across teams.

• Design for user zero first
  Build tools and features that solve your own immediate needs (e.g., ZEDs initial creation for personal workflow optimization) before scaling for others, while iteratively incorporating feedback from team members and the community.

• Track granular code changes and interactions
  Use a system that records every character-level change and ties them to conversational context (e.g., Delta DBs DAG structure) to improve traceability, accountability, and collaboration without relying on fragmented tools like markdown files or external databases.