🤖 AI

From Context to Intent: Reasoning-Guided Function-Level Code Completion

This paper proposes a reasoning-guided framework that enhances function-level code completion in the absence of docstrings by training Large Language Models to infer developer intent from implicit code context through step-by-step reasoning, supported by a new 40k-example dataset and an interactive platform for human feedback.

Original authors: Yanzhou Li, Tianlin Li, Yiran Zhang, Shangqing Liu, Aishan Liu, Xianglong Liu, Yang Liu

Published 2026-03-25

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Yanzhou Li, Tianlin Li, Yiran Zhang, Shangqing Liu, Aishan Liu, Xianglong Liu, Yang Liu

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are a master chef (the AI) working in a busy kitchen. A sous-chef (the developer) hands you a half-finished recipe card and says, "Finish this dish."

The Problem:
Usually, the recipe card is missing the most important part: the name of the dish or a description of what it's supposed to taste like. It just lists a few ingredients you've already chopped and a blank space for the final instructions.

If you just guess, you might make a delicious lasagna when they actually wanted a spicy stir-fry. You have the ingredients (the code context), but you don't know the intent (the goal). In the world of coding, this is why AI often writes code that looks right but does the wrong thing.

The Old Way vs. The New Way:

The Old Way (Direct Completion): The AI looks at the ingredients and guesses the dish. It's fast, but often wrong.
The "Magic Note" Way (Docstrings): If the developer wrote a note saying "Make a lasagna," the AI would be perfect. But in real life, developers are busy and rarely write these notes.
This Paper's Solution (Reasoning-Guided): Instead of guessing, the AI is taught to think like a detective before it starts cooking.

How It Works: The Three-Step Detective Process

The researchers taught the AI a new habit: Stop, Think, Then Act. They created a system where the AI must write down its "thought process" before writing a single line of code.

Look at the Clues (Lexical Analysis):
The AI looks at the file name (e.g., legacy_export.py) and the function name (e.g., convert_payload). It's like seeing a label on a box that says "Fragile: Old Electronics." The AI thinks, "Okay, this isn't a new gadget; it's probably for an old system."
Read the Story So Far (Semantic Analysis):
The AI reads the code written before the empty space. It sees other functions like write_legacy_file (which saves things in an old format) and compress_payload. It realizes, "Ah, everyone else here is preparing data for an old system. The missing piece must be the part that actually formats the data for that old system."
State the Goal (Intent Inference):
Before writing code, the AI writes a clear summary: "I need to take this data, filter out the new stuff, and turn it into an old-fashioned XML file." This is the "intent."

Once the AI has written this "thought summary," it then writes the code. Because it knows exactly what it's trying to achieve, the code is much more accurate.

The "Human-in-the-Loop" Twist

Sometimes, even a detective can be slightly off. Maybe the AI thinks the file should be XML, but the developer actually wanted JSON.

To fix this, the paper introduces a Lightweight Interaction step.

The AI generates three possible guesses for what the dish should be (e.g., "XML version," "JSON version," "CSV version").
The developer can quickly tap one to say, "Yes, that's it!" or make a tiny edit: "Actually, change 'XML' to 'JSON'."
The AI then cooks the dish based on that confirmed plan.

This is like the chef asking, "Are we making lasagna or stir-fry?" before starting. It takes a split second but saves the chef from making a huge mistake.

Why This Matters (The Results)

The researchers tested this on thousands of real-world coding tasks.

Without thinking: The AI got the job right about 20% of the time.
With the "Detective" training: The AI got it right over 29% of the time (a huge jump!).
With the "Human Check": It got even closer to perfect.

They also found that this "thinking" process works even if the AI is smaller or if the code is written in a different language (like Java), proving that the skill of understanding context is universal.

The Bottom Line

This paper teaches AI to slow down and think before it acts. Instead of blindly guessing what code to write next, it learns to read the room, understand the developer's hidden goal, and confirm that goal before building. It turns the AI from a fast-but-clumsy guesser into a thoughtful, reliable partner.

1. Problem Definition

The paper addresses the challenge of function-level code completion in real-world software development scenarios where explicit instructions (such as docstrings) are frequently absent.

The Gap: While Large Language Models (LLMs) perform well when given clear docstrings, they struggle significantly when required to infer the developer's intent solely from the surrounding code context (file name, preceding code, and function signature).
The Core Issue: Current models often fail to extract implicit cues from the context to understand the high-level purpose of a function. This leads to generic or incorrect implementations.
Motivation: A preliminary study showed a massive performance gap (over 40% relative improvement in Pass@1) when ground-truth docstrings were provided versus when they were missing, indicating that models cannot reliably infer intent from context alone.

2. Methodology

The authors propose a Reasoning-Guided Framework that forces the model to explicitly infer the developer's intent before generating code. This is achieved through two main components:

A. Reasoning-Based Prompting Framework

Inspired by human cognitive processes and Chain-of-Thought (CoT) reasoning, the authors designed a structured prompt template to guide the model through three specific steps:

Lexical Inference: Analyzing naming conventions (file name, function name, argument names) to form an initial hypothesis about the function's domain and role.
Semantic Analysis: Examining the preceding code to identify existing helper functions, control structures, and variables. The model determines what functionality is already implemented and what "gap" remains.
Intent Synthesis: Combining the lexical and semantic insights to generate a descriptive docstring that explicitly defines the intended functionality, arguments, and return values.

B. Supervised Fine-Tuning (SFT)

Since relying solely on prompting is inefficient and unreliable for smaller models, the authors created a specialized training dataset to internalize this reasoning process:

Dataset Construction: They curated 40,000 examples from open-source Python repositories.
- Seed Data: 50 high-quality examples were manually annotated by experts with structured reasoning traces and docstrings.
- Expansion: GPT-4o was used to expand this seed set into 40k instances, generating reasoning traces and docstrings for new function contexts.
- Validation: Automated filtering and human auditing ensured the reasoning traces were semantically aligned with the ground-truth code.
Training Strategy: Models (CodeLlama-7B/13B and DeepSeekCoder-16B) were fine-tuned on this dataset. The input consists of the context, and the target output is a sequence containing the reasoning trace, the inferred docstring, and finally the code. Special tokens (<reasoning>, <docstring>, <code>) delineate these phases.

C. Three-Stage Intent-Interactive Framework

To further align the model with user goals, a lightweight interactive pipeline is introduced:

Inference: The model generates $k$ candidate docstrings (intentions).
User Interaction: Developers can either select the best candidate or perform lightweight editing (e.g., correcting return types or keywords).
Generation: The model generates the final code based on the refined intention.

3. Key Contributions

Problem Identification: Revealed that current LLMs fail to accurately infer function intent from implicit context, leading to poor completion quality without explicit guidance.
Reasoning Framework: Proposed a step-by-step reasoning framework (Lexical $\to$ Semantic $\to$ Synthesis) to guide LLMs in inferring intent.
Dataset & Fine-Tuning: Created a 40k-example dataset with structured reasoning traces and used SFT to equip models with the ability to autonomously reason about intent.
Interactive Pipeline: Developed a three-stage workflow allowing for optional, low-effort human feedback to refine intent, bridging the gap between automated inference and user expectations.
Plug-and-Play Module: Demonstrated that the fine-tuned reasoning model can serve as a lightweight module to enhance the performance of larger, proprietary models (e.g., GPT-4o, DeepSeek-V3).

4. Experimental Results

The approach was evaluated on two benchmarks: Deveval (1,211 valid Python functions) and ComplexCodeEval (773 Python functions).

Performance Gains:
- Pass@1: Achieved >25% relative improvement (and >7.5% absolute) over baseline models (Direct generation and simple Intent prompting).
- CodeBLEU & EditSimilarity: Consistently improved by 5.5% or more.
- Comparison: The reasoning-enhanced model significantly narrowed the performance gap to the "Oracle" setting (where ground-truth docstrings are provided), reducing the Pass@1 difference from >15% to <4%.
Interactive Framework:
- Adding user selection and editing improved Pass@1 by an additional ~2.6% over the automated reasoning model.
- It increased the semantic alignment (cosine similarity) between the generated intention and the oracle intention.
Efficiency:
- While reasoning adds latency (approx. 1.44s per function vs. 0.61s for direct), the trade-off is acceptable given the quality gains.
- A reasoning-based 7B model outperformed a 16B model using direct generation in terms of quality at a similar inference cost.
Generalization:
- Cross-Language: The model, trained only on Python, successfully transferred to Java (ComplexCodeEval subset), showing consistent relative improvements.
- Plug-and-Play: Using the fine-tuned 7B model to infer intent for larger models (GPT-4o, DeepSeek-V3) improved their Pass@1 scores significantly compared to zero-shot or 2-shot prompting.

5. Significance

This paper makes a significant contribution to the field of AI-assisted software engineering by shifting the focus from context retrieval (RAG) to intent inference.

Practicality: It solves a critical real-world problem where developers do not write docstrings, yet expect AI to understand their code.
Paradigm Shift: It demonstrates that structured reasoning about what code should do is more valuable than simply providing more context or relying on raw model size.
Scalability: The proposed "Plug-and-Play" module suggests a cost-effective architecture where small, specialized models handle the complex reasoning of intent, while larger models focus on code generation, optimizing both cost and performance.
Human-in-the-Loop: The interactive framework provides a practical mechanism for developers to correct AI misunderstandings with minimal effort, making the tool more reliable for production use.