Context beats modeling: 45% less code typing due to intent-based completions model

In-line code completions are the foundation of any great AI coding experience, and the first place software engineers interact with AI tools like Augment Code. While our completions model was already strong, we knew there was opportunity to improve it. By training completions to understand developer intent, we significantly boosted relevance, accuracy, and flow. Every Augment plan includes unlimited completions — happy coding!

Why Completions Matter

Code completion is one of the most mature and widely adopted AI tools in the modern developer workflow. While the buzz today is around AI agents, many professional software engineers still rely on completions as their primary way of interacting with AI. And for good reason: it’s lightweight, frictionless, and already embedded in the natural rhythm of writing code.

But in-line completions are more than just a convenience: they're foundational. Completions are where trust is built. When they just work, developers gain confidence to rely on AI not only for suggestions, but eventually for autonomous decisions and larger tasks.

At Augment, our completions model was already battled tested:

• Trained on large-scale, real-world developer usage
• Augmented by retrieval to improve local context
• Tuned for precision, quality, and latency

But even with strong performance, something was still missing. The model understood code, but not how or why the code was changing.

That may sound subtle, but bridging this gap has real impact.

Our strategy for improving completions

Consider this: you’re mid-edit in a file, tweaking a function signature, updating logic, or adding a new field. Traditional completions might give you something syntactically valid, maybe even semantically relevant. But it doesn’t know what you’re trying to do - only what it sees.

To get better, we had to go beyond the surface of static code snapshots. We needed to understand your flow. What change did you just make? What files have you been editing? What are you in the middle of doing?

This shift, from seeing code as a static document to viewing it as a live stream of intent, mirrors what we did with our Next Edit feature. There, edit events transformed our ability to suggest cross-file refactors. Now, we’ve brought that same philosophy to completions.

Here’s an example of how the prior model can be confused due to conflicting information in a static code snapshot.

+@dataclass
+class FilterConfig:
+   model_filter: Optional[str] = None
+   license_filter: bool = False
+   edit_filter: bool = False
+   limit_filter: Optional[int] = None

def process_data(
	  input_dir: Path,
	  output_dir: Path,
-	  license_filter: bool = False
-	  edit_filter: bool = False
-	  limit_filter: Optional[int] = None
+   filter_config: FilterConfig
) -> None:
	  if license_filter:
	    apply_license_filter(input_dir, output_dir)
	  if edit_filter:
	    apply_edit_filter(input_dir, output_dir)
	  if limit_filter:
	    apply_limit_filter(input_dir, output_dir)
    
def clean_training_data():
    process_data(
        input_dir=Path("data/raw"),
        output_dir=Path("data/clean"),
        model_filter="gpt-4",
        license_filter=True,
    )

def process_benchmark_data():    
    process_data(
        input_dir=Path("data/benchmark"),
        output_dir=Path("data/processed"),
				<COMPLETION>

If the model only sees the final state of the code, it can be confused between following the usage (Option A) or the signature (Option B):

• Option A: model_filter="claude-3", license_filter=True, limit_filter=2000)
• Option B: filter_config=FilterConfig("claude-3", True, limit_filter=2000)

Since we now present the model the diff, it knows to follow the updated signature and can confidently suggest Option B.

We also see this in many other real examples:

• A developer renames a variable, and completions use the new name in follow-up suggestions.
• A condition is subtly added in one file, and completions in another adjust to avoid assuming the old behavior.
• A function is split into two, and completions suggest the appropriate one based on usage.

These examples aren’t just nice-to-haves. When completions are aware of your edit events, they reflect the direction you want the code to go, not where it is now.

The Results

Intent-awareness drives the single largest improvement we’ve seen across our internal benchmarks, surpassing gains from base model upgrades, smarter retrieval chunking, RL tuning, and data curation.

Our latest release improves exact match on an internal benchmark by +3.9% against the baseline — outpacing the +1.3% gain from RL-driven post-training and far beyond the other gains from prior improvements. The trend in the chart is clear: while the training recipe is important, providing the right context is essential. If we incorporate edit events into completions, models can leverage your edits to understand why your code is changing. But without the right information, there's nothing to leverage.

Evolution of our code completion model: Each improvement builds on the previous version, with Edit Events delivering the largest single upgrade in our completion model's development history. Ordered by the incremental gain over the previous model, the improvements smallest to largest thus are better data curation (+0.2%), smart chunking (0.4%), RLDB (1.3%), better base model (1.5%), and edit events (+2.6%).

It's not just on benchmarks. We're also seeing this reflected in real developer usage where completions are enabling users to produce more code while typing less in the editor. Before the change, the characters written by completions accounted for 36% of edits in the editor, whereas the new model now accounts for 45% of edits, a 25% increase in completions-driven output. For developers, that means they can type another 14% less between models.

What’s Next

Completions is our most mature model, but there’s still so much more we can do with deeper context awareness.

Understanding the flow of development, not just its static state, is the key to unlocking smarter assistance. Whether it’s your next keystroke or your next pull request, we want the model to know what you’re doing and help you do it faster. See for yourself and try it out.

P.S. if you're excited about building the future of AI for software development, we're hiring.