Next Edit powered by Mercury Coder

We are excited to share that Continue now features Next Edit as a feature suite, powered by Inception. This represents a fundamental shift in how AI assists your coding from simple autocomplete to intelligently predicting and suggesting complex code edits before you make them.

The Evolution from Autocomplete to Edit Prediction

Traditional AI coding excels at completing code as you type, but developers spend significant time editing existing code, refactoring methods, updating variable names, restructuring logic, and fixing bugs. These tasks require understanding not just what to add, but also what to change, move, or remove across multiple locations simultaneously.

"Next Edit is the logical next step forward when it comes to AI-assisted coding," explains Jacob Kim, software engineer at Continue who led the implementation. "Autocomplete is great at adding, but it's not good at deleting, replacing, or doing anything that's not strictly addition. Most developers will tell you that writing code isn't the issue but maintaining what's already there and fixing what's broken is the more difficult part."

Next Edit addresses this reality. Instead of waiting for you to highlight code and describe changes, it anticipates your editing patterns and proactively suggests multi-line edits based on your current context and cursor position. Think of it as having a pair programmer who not only knows what you're about to type, but understands what you're about to refactor.

Why Next Edit Feels Different: Powered by Mercury's Ultra-fast Diffusion Models

Next Edit leverages Mercury Coder's diffusion-based architecture, achieving 700-1100 tokens per second—a 5-10x improvement over traditional autoregressive models. This speed isn't just about raw performance; it fundamentally changes the editing experience.

"I was amazed by how fast it was. The multi-thousand tokens per second was absolutely wild, nothing like I've ever seen," says Jacob. "Before, I used to be a diffusion skeptic. I thought they wouldn't be ready anytime soon because I felt a lot of what they generate would be gibberish. Then Mercury drops, and it's actually really cool. It works great, it's coherent, it's relevant, it's fast."

How It Actually Works

Traditional AI models think about code the same way you read a sentence: left to right, one word at a time. Mercury's diffusion approach is more like how you actually edit code—understanding the whole picture and making changes everywhere they're needed simultaneously.

This means Next Edit can predict:

• Deletions in one section
• Additions in another
• Structural changes throughout your file

All at the same time, all in context.

What 100ms Feels Like

With average latency under 100ms, suggestions appear so quickly that Next Edit feels less like waiting for an AI tool and more like your IDE reading your mind. You position your cursor, and the suggestion is already there.

"We're incredibly excited for Mercury Coder, the world's first diffusion LLM, to be the default LLM for Continue's new Next-Edit feature," Aditya Grover, CTO of Inception, shares. "With this launch, we are also making the next-edit endpoint generally available on our API platform. This launch marks a shift from autocomplete to a richer and smarter editing, putting AI directly into the flow of how development happens. For us, this isn't just about speed - it's about redefining the developer experience. With Next-Edit, powered by Mercury, engineers can spend less time on mechanical changes and focus on creative problem-solving. That's the kind of transformation we've been building towards at Inception."

Learning from real developer workflows

What makes Next Edit particularly effective is its training on actual edit sequences from the internal Continue team’s development data. The model learned rather than synthetic completions, the model learned from real refactoring patterns, bug fixes, and code improvements that developers make daily.

"The defining feature of this data is that it's very real. It's pretty much the rawest form of developer edit data you're going to get," explains Adarsh Iyer, a Continue Intern this summer. "It's literally the exact edit that an advanced developer would make. Mercury has trained on about 10 times as much real next-edit data as anybody else has, at least in open source."

This approach means Next Edit understands common editing patterns like:

• Converting callback patterns to async/await
• Extracting repeated code into reusable functions
• Updating method signatures and their call sites
• Restructuring conditionals for clarity
• Fixing common anti-patterns and code smells

The model predicts what changes you're likely to make based on patterns it's observed from thousands of real editing sessions.

Beyond simple completions

Next Edit shines in scenarios where traditional autocomplete falls short. When you position your cursor near problematic code, it can suggest comprehensive fixes that span multiple lines. When you start renaming a variable, it anticipates all the places that need updating. When you begin extracting a function, it understands the full refactoring scope.

The system provides the model with comprehensive context and editing patterns, ensuring it understands both the broader goal and the fine-grained details of your work. Through the ultra-fast diffusion process, the model integrates this information into an expressive next edit, allowing you to edit at the speed of thought.

Try Next Edit today

Next Edit is rolling out now to all Continue users on Models Add-On. To get started:

1. Update to the latest Continue extension in VS Code or JetBrains
2. Next Edit will automatically activate when the Mercury model is available
3. Navigate to any code you want to edit—suggestions will appear inline
4. Accept edits with Tab, or cycle through alternatives with Alt+]

For teams who want to customize Next Edit for their specific codebases and patterns, you can configure custom edit patterns in your Continue configuration. Join our Discussions to share your experience with Next Edit and see how other developers are using predictive editing to accelerate their workflows. As always with Continue, you maintain full control. Next Edit runs alongside our existing chat, autocomplete, and agent features, giving you the right AI assistance for each situation.

Not that long ago, autocomplete changed the way we thought about writing code: the machine could guess, sometimes even better than we could. But the real work of development is about shaping, re-shaping, and often undoing what came before. Next Edit closes that loop. By learning from real edit sequences, it brings AI into the heart of development, where change is constant and context matters most. AI tools have promised to make developers faster at writing code. Next Edit points to a reality where the biggest impact may come from teaching AI to edit alongside us, the way real development happens.