MelcotCR: Fine-Tuning Framework for Code Review

• MelcotCR is a fine-tuning framework for LLMs that decomposes automated code review into sub-tasks like functionality summarization and impact analysis.
• It leverages long chain-of-thought prompting and maximum entropy fine-tuning to generate diverse, contextually rich review outputs.
• Empirical results show that a 14B-parameter model fine-tuned with MelcotCR outperforms larger baselines in precise issue localization and review quality.

MelcotCR is a fine-tuning framework for LLMs, designed to advance automated code review by enabling multi-dimensional analysis and sophisticated reasoning. The approach harnesses long chain-of-thought (COT) techniques and integrates the Maximum Entropy (ME) modeling principle, resulting in high-accuracy detection and description of code issues even with relatively low-parameter models. MelcotCR explicitly decomposes the code review task into several sub-tasks—such as code functionality summarization, core logic analysis, change impact analysis, and direct inspection of issues—thereby structuring the reasoning process to more closely mirror human review methods. Evaluations demonstrate that a 14B-parameter model fine-tuned via MelcotCR surpasses state-of-the-art baselines and matches the performance of considerably larger models.

1. Structured Decomposition of Automated Code Review

MelcotCR addresses limitations of previous automated code review systems, which typically performed direct mappings from code snippets to review comments. Instead, MelcotCR operationalizes the review process as a sequence of sub-tasks, encompassing:

• Functionality summarization
• Core logic analysis
• Change impact (“diff”) analysis
• Direct issue detection and resolution suggestion

This multi-dimensional decomposition reflects established human review practices and enables the systematic targeting of code quality along various axes. Each sub-task is designed to elicit explicit intermediate steps from the model, producing a more transparent and interpretable review process.

The fine-tuning pipeline leverages custom-crafted COT prompts, modeled on real code reviews, ensuring that the model internalizes both the sequence and interleaving of reasoning tasks as part of its learned behavior.

2. Long Chain-of-Thought Prompting

The core methodological contribution of MelcotCR is its adoption and extension of long chain-of-thought prompting within code review. Unlike approaches that generate one-step or two-step outputs (e.g., localize issues then comment), the long COT paradigm in MelcotCR elicits a sequence of structured intermediate outputs. The process can be formalized as a mapping:

$$x_{\text{code}} \rightarrow (s_{\text{func}}, s_{\text{logic}}, s_{\text{impact}}, s_{\text{issue}})$$

where each $s_i$ represents one explicitly prompted sub-task. This separation enforces logical tightness, allows for backtracking and error correction, and exposes the full reasoning trace.

The explicit stepwise reasoning paradigm yields:

• Increased accuracy for issue localization, as measured by Intersection over Union (IoU) metrics
• Higher-quality, contextually rich review comments, as validated by human and automated metrics

3. Maximum Entropy Modeling in Fine-Tuning

A principal innovation of MelcotCR is the incorporation of the Maximum Entropy (ME) principle within the supervised fine-tuning objective, leading to what the authors term ME-regulated fine-tuning (MEFT). ME modeling seeks the probability distribution with maximal entropy under imposed constraints, thereby minimizing inductive bias and allowing the model to generalize more effectively over diverse valid reasoning trajectories.

For each code review prompt, MelcotCR generates $n$ (e.g., $n=10$) semantically correct yet lexically/syntactically distinct answer variants. The MEFT loss function is:

$$\mathcal{L}_\text{ME(FT)}(x) = \sum_i \log P\left(\{x_{i,1}, x_{i,2}, \ldots, x_{i,n}\}\mid x_{<i}\right)$$

This approach encourages the parameterization of the model to favor broader, bias-invariant coverage of the answer space, as opposed to converging on isolated canonical forms. The effect is a demonstrable resistance to overfitting, improved generalization to previously unseen review styles, and higher-fidelity modeling of the multi-step reasoning process.

4. Empirical Validation

MelcotCR’s effectiveness was validated using both a curated MelcotCR dataset and the public CodeReviewer dataset. The key experimental results include:

• On the MelcotCR dataset, Qwen2.5 (14B) fine-tuned with MelcotCR outperformed the CarLLM baseline across precise code issue localization (IoU) and review comment accuracy metrics.
• Human evaluation (metrics: Human Hit and Human Valuable) confirmed that MelcotCR outputs are more accurate and actionable than baselines.
• On the CodeReviewer dataset (out-of-distribution regarding MelcotCR's training), MelcotCR achieved review quality on par with the 671B DeepSeek-R1 LLM, despite the latter’s much higher parameter count.

These results indicate that incorporating ME-regulated fine-tuning with long COT techniques enables highly competitive code review quality with significantly reduced computational requirements.

5. Implementation Techniques

The realization of MelcotCR necessitated several technical strategies to address the challenge of long token sequences and efficient resource utilization:

• Use of Flash Attention and DeepSpeed Zero3 to support long input sequences and decrease memory overhead during training.
• Custom structured chain-of-thought prompts mirroring expert human review procedures, capturing the sequence—functionality comprehension, diff analysis, and issue identification.
• Distinct loss functions for traditional fine-tuning ($\mathcal{L}_\text{LLM}$) and MEFT ($\mathcal{L}_\text{ME(FT)}$), formalized as follows:

Loss Name	Formula	Description
Standard Fine-Tuning	$$\mathcal{L}_{LLM}(x) = \sum_{i} \log P(x_i \mid x_{<i})$$	Predict each token sequentially
Maximum Entropy (MEFT)	$$\mathcal{L}_\text{ME(FT)}(x) = \sum_{i} \log P\left(\{x_{i,1},...,x_{i,n}\}\mid x_{<i}\right)$$	Predict token sets (paraphrases)

This architecture and the supporting workflow enable MelcotCR to operationalize long, structured COT reasoning while maintaining tractable memory and compute.

6. Implications and Prospects

MelcotCR opens several pathways for both applied and methodological advancement:

• Enhanced Automated Code Review: MelcotCR provides actionable, multidimensional review outputs, improving both precision and utility relative to prior approaches.
• Human-AI Collaboration: The stepwise COT traces afford human reviewers insight into the rationale for flagged issues, facilitating collaborative verification and correction workflows.
• LLM Fine-Tuning Paradigms: The demonstrated parity of a 14B MelcotCR model with the 671B DeepSeek-R1 suggests that greater reasoning capacity, not parameter count alone, is decisive for practical code review tasks. This points toward further research on architectural and algorithmic innovations in reasoning-centric LLM fine-tuning.
• Generalization to Other Reasoning Domains: A plausible implication is that the structured, ME-regulated COT methodology may be adaptable to other domains where complex, multi-step reasoning is required, subject to appropriate prompt engineering and domain-specific decomposition.

Potential future directions include expanding the decomposition dimensions (e.g., additional paraphrasing or reasoning stages) and introducing online reinforcement learning to further boost review quality.

7. Summary

MelcotCR represents a formalization of automated code review grounded in explicit multi-dimensional analysis and robust reasoning via long chain-of-thought prompting. By coupling this decomposition with maximum entropy fine-tuning, MelcotCR enables low-parameter LLMs to match or exceed the practical performance of much larger models. The methodology’s empirical strengths and architecture open new directions in both program analysis and advanced LLM research (Yu et al., 25 Sep 2025).