Overview: Melty is an AI-powered code editor designed to transform how developers interact with their code by treating every chat interaction as a git commit. Unlike traditional AI coding assistants that generate snippets in isolation, Melty integrates directly with your version control system, automatically creating commits for every change suggested or approved in a conversation. This allows developers to revert, branch, reset, and squash their chat-driven changes just like regular code commits. Built by former Replicate and Netflix engineers, Melty addresses the pain points of juggling multiple chat sessions, copy-pasting code, and losing context between AI-generated changes. It’s designed for developers who want to leverage AI for large-scale refactoring and multi-file changes while maintaining full traceability and control over their codebase.
Melty is not a plugin or extension—it’s a standalone editor built from the ground up with TypeScript, designed to act as a pair programmer that never forgets context. It watches every change you make, learns your codebase over time, and integrates with existing tools like compilers, debuggers, GitHub, and Linear. Currently in early access (v0.2), Melty is already capable of writing significant portions of its own codebase and supports real-time demos for refactoring, web app creation, and navigating large codebases.
What You Get
- Every chat message is a git commit - Melty automatically creates commits for every AI-generated change or user-approved suggestion, allowing full version control integration—revert, branch, reset, and squash conversations like code changes.
- Multi-file refactoring - Melty can refactor code across multiple files in a single conversation, maintaining consistency and context without requiring manual copy-pasting between files.
- Web app creation from scratch - Users can generate entire web applications through conversational prompts, with Melty creating files, setting up dependencies, and structuring projects end-to-end.
- Codebase navigation with AI context - Melty understands the structure and patterns of your codebase, enabling intelligent navigation and suggestions based on project-specific context.
- Self-referential development - Melty has already written about half of its own codebase, demonstrating its ability to understand and extend complex applications autonomously.
Common Use Cases
- Building a multi-file React application with state management - A developer describes the desired UI and functionality in chat; Melty creates component files, hooks, state stores, and routing—all as discrete commits—with the ability to rollback if a component breaks.
- Refactoring a legacy Node.js service into microservices - A team uses Melty to identify and extract modules across dozens of files, with each extracted service committed individually for review and testing.
- Problem: Lost context between AI-generated code snippets → Solution: Melty ties every change to a commit hash, so you can trace why a line was added or removed just like regular git history
- Team workflows with non-expert contributors - Junior developers or product team members can suggest changes via chat, and Melty generates safe, commit-tracked modifications that senior engineers can review before merging.
Under The Hood
This project is a large-scale, multi-language development environment built on top of the VS Code ecosystem with extensive support for TypeScript, JavaScript, and cross-platform extension capabilities. It combines Electron-based desktop functionality with a modular architecture that enables flexible plugin systems and runtime adaptability.
Architecture
This codebase adopts a highly modular and layered structure that emphasizes separation of concerns and extensibility through plugins.
- The architecture supports a component-based UI rendering model with well-defined entry points for extensions
- It implements middleware-style processing to handle cross-cutting concerns like state management and event handling
- Clear module organization enables scalable growth and maintainable code across multiple domains
- Design patterns such as dynamic import maps and conditional resolution support dual-bootstrapping environments
Tech Stack
Built primarily in TypeScript and JavaScript, this project leverages a rich ecosystem of tools and frameworks tailored for VS Code and Electron environments.
- The tech stack centers around Node.js, Electron, and the VS Code extension API with extensive use of React and Xterm for UI components
- Key dependencies include @vscode, vscode-uri, react, and @xterm for runtime and rendering capabilities
- Build tools such as webpack, gulp, and esbuild are integrated to support extension packaging and deployment workflows
- Testing is conducted using mocha, sinon, and other utilities within the VS Code extension framework to ensure reliability
Code Quality
This project demonstrates a mature development approach with strong emphasis on testing, consistency, and error resilience.
- Comprehensive test coverage spans unit, integration, and end-to-end scenarios to ensure robust functionality
- Error handling is consistently applied through widespread use of try/catch blocks and exception management patterns
- Code follows consistent naming conventions and architectural styles with minimal duplication across modules
- Despite good structure, some legacy code and complex integration points introduce moderate technical debt
What Makes It Unique
This project introduces several innovative approaches to extension handling, runtime flexibility, and performance optimization in a multi-platform environment.
- Implements an advanced AMD/ESM module loading system with secure script execution through trusted types policies
- Features a dual-bootstrapping architecture that supports both Node.js and browser environments seamlessly
- Offers a rich extension ecosystem with language server integration, webview rendering, and stateful UI components
- Includes performance monitoring and memory-efficient utilities such as async pipes and ring buffers for resource management