For Intelligent Code Review, identifying common issues is only the first step. Whether it can understand the technical constraints, business rules, and team preferences that have developed in a repository over time determines whether its review comments are truly trustworthy. Alibaba Cloud DevOps Intelligent Code Review now offers Review Memory, a capability that captures context already clarified during reviews as reusable rules, grounding future reviews in the team's actual engineering practices.
During a code review, Intelligent Code Review suggested removing a DTO's no-argument constructor. The developer promptly explained: "This constructor cannot be removed. The legacy compatibility path creates objects through reflection." A few days later, a similar change appeared in another merge request (MR), yet the team had to explain the same rule again.
This kind of repeated communication is common. Intelligent Code Review can identify common code issues, but every repository has some background that is difficult to reconstruct from the current code diff alone: interfaces still called by legacy systems, the team's standard approach to exception handling, and related logic that must be updated whenever a particular field is changed.
Many review comments that seem reasonable but do not reflect the repository's actual circumstances are often caused by missing long-term context.
Alibaba Cloud DevOps Intelligent Code Review now offers Review Memory. Teams can save rules already explained clearly during reviews as review memories for the current repository. Once these memories take effect, future reviews will consider this information when evaluating relevant changes, reducing repeated discussions of the same kinds of issues.
Review Memory does more than simply save temporary comments: it captures information that can be reused over the long term as repository context. The following four categories are particularly suitable:
| Memory type | Typical content | Value for reviews |
|---|---|---|
| Repository rules | Established conventions that specific packages, modules, classes, or interfaces must follow | Reduce missed issues or false positives caused by unfamiliarity with repository standards |
| Business constraints | Background such as compatibility with legacy paths, fields in external systems, and staged rollout requirements | Ensure review comments account for actual business risks rather than considering only the code at face value |
| Team preferences | Long-standing implementation approaches, naming styles, and exception-handling strategies | Reduce repeated discussions of the same preferences across different MRs |
| Risk-related experience | Types of changes that have historically been prone to causing problems and require additional checks | Provide more targeted risk alerts in similar scenarios |
The core value of Review Memory is turning tacit knowledge that relies on verbal communication by individual members into explicit rules that future reviews can continue to use.
The following two scenarios illustrate more clearly how it informs review judgments.
A developer modified code that saves product information, and Intelligent Code Review flagged the following issue: "The modification timestamp is not updated here, which may result in inaccurate data." In this project, however, the database has always maintained modification timestamps automatically, so the business code does not need to assign them again.
The team can add the following comment:
Please remember: The database automatically updates modification timestamps in the product table. When saving product information, the business code does not need to assign these values manually.
Once the memory takes effect, future reviews of similar code will consider how the database handles these values. This reduces comments such as "the lack of a manual assignment is an omission," which do not reflect the project's actual circumstances.
In an e-commerce application, orders delivered by courier must include a shipping address, while in-store pickup orders only require the customer to select a pickup store. If Intelligent Code Review only compares the differences in validation between the two order-placement flows, it may conclude that pickup orders are missing address validation.
The team can explicitly tell Intelligent Code Review:
Please remember: In-store pickup orders do not require a shipping address, but a pickup store must be selected. Only orders delivered by courier require shipping address validation.
This memory both helps reviews recognize valid differences between the two flows and provides a basis for checking future changes that omit pickup store validation.
Take DTOs used for compatibility as an example: DTOs in a particular package must retain a public no-argument constructor. Although the current business code rarely calls it directly, the legacy compatibility path still needs it to create objects through reflection.
Developers can tell the Alibaba Cloud DevOps AI Assistant in an MR comment:
Please remember: In the
com.example.compat.dtopackage, all classes whose names end in DTO must retain a public no-argument constructor.
The system will organize this information into a candidate memory for the current repository. Once the memory takes effect, Intelligent Code Review will use this rule as a basis for its judgments when the same or similar scenarios appear in future MRs. If someone does remove one of these constructors, it can also use the rule to remind the team to check whether the legacy path has been affected.
Review Memory provides rules, their scope of application, and the engineering reasons behind them to inform future judgments.
Users proactively tell Intelligent Code Review in a comment what they would like it to remember.
During reviews, Intelligent Code Review automatically uses memories that have taken effect.
To validate the practical effectiveness of Review Memory, the Alibaba Cloud DevOps team built a test set and conducted comparative tests. The tests focused on whether memories could reduce incorrect review comments caused by missing information, a lack of repository context, or unfamiliarity with team conventions.
For the samples in this test set, using Review Memory reduced incorrect review comments by 96.9%. This means that most incorrect comments previously caused by missing project context were effectively suppressed by the constraints provided by relevant memories.
96.9% represents the reduction in incorrect comments on this internal test set. Its direct value is in validating that "adding repository context can significantly reduce specific types of false positives." It is not an overall accuracy rate applicable to all repositories and all review scenarios.
For development teams, this change is mainly reflected in three areas:
Team experience is suitable as a basis for future reviews only when it is accurate, remains valid over the long term, and has clearly defined boundaries. If one-off scenarios or incompletely expressed feedback are allowed to take effect directly and remain in force over the long term, they may instead introduce new errors in judgment. Review Memory therefore needs governance as well as accumulation.
While providing Intelligent Code Review with long-term context, it is also important to ensure that this context can be reviewed, revised, and disabled.
Repository administrators can go to "Repository Settings — AI Assistant Settings — Intelligent Code Review — Review Memory" to enable or disable Review Memory for the current repository.
Administrators can also enable memory approval to meet their team's needs. Once it is enabled, newly generated candidate memories must be confirmed by an administrator before they take effect. Administrators can view, edit, approve, reject, disable, re-enable, or delete memories, preventing information about one-off scenarios, unclear descriptions, or content unsuitable as long-term rules from being used in future reviews.
An effective review memory must not only explain "what should be done," but also tell Intelligent Code Review where the rule applies, why it exists, and under what circumstances an alert is needed.
| Element | What needs to be specified |
|---|---|
| Scope of application | Which repository, module, directory, or type of code the rules apply to |
| Specific rules | What must be done or must not be done |
| Underlying reasons | The relevant business context, compatibility requirements, or team conventions |
| Follow-up actions | What situations in future reviews should trigger alerts or checks, and how those alerts or checks should be carried out |
The more specific the rules and the clearer their boundaries, the easier it is to use memories accurately in future reviews.
You can start with the following basic template:
Please remember: When [type of change] occurs within [scope or specific scenario], follow [rules or requirements] because [business context or technical reasons]. If the requirements are not met, flag [risks that need to be checked].
Compared with simply saying "do not change this," fully describing the rules and their reasons better enables Intelligent Code Review to make sound judgments in scenarios that are similar but not identical.
The quality of code reviews depends not only on the ability to identify common code issues, but also on the ability to understand the engineering constraints that have developed in a repository over time. Review Memory transforms team knowledge scattered across comments, individual experience, and repeated discussions into context that future reviews can continue to use, taking Intelligent Code Review beyond one-off code analysis toward ongoing collaboration based on team rules.
The boundaries of this capability are equally clear: rules that remain valid over the long term and have a clearly defined scope are more suitable for inclusion in Review Memory. Teams can also enable administrator approval and perform ongoing maintenance according to their governance requirements, improving review accuracy while keeping the rules themselves reliable.
If you are already using Alibaba Cloud DevOps Intelligent Code Review, you can go to "Repository Settings — AI Assistant Settings — Intelligent Code Review — Review Memory" to enable this capability. Start by capturing the rule that needs to be explained repeatedly in your next MR.
Alibaba Cloud DevOps AI intelligent code review documentation: https://www.alibabacloud.com/help/en/yunxiao/user-guide/ai-intelligent-code-review
Alibaba Cloud DevOps official website: https://www.alibabacloud.com/en/product/devops
AI-powered Work Item Refinement in Alibaba Cloud DevOps: Clarify Before You Start
809 posts | 61 followers
FollowAlibaba Cloud Native Community - November 9, 2026
Alibaba Cloud Community - March 1, 2022
Alibaba Cloud Community - July 23, 2026
Alibaba Cloud Native Community - June 25, 2026
Alibaba Clouder - July 18, 2018
Biexiang - April 14, 2021
809 posts | 61 followers
Follow
DevOps Solution
Accelerate software development and delivery by integrating DevOps with the cloud
Learn More
Qoder
From Assisted to Autonomous — Adapting to Every Programming Need
Learn More
Conversational AI Service
This solution provides you with Artificial Intelligence services and allows you to build AI-powered, human-like, conversational, multilingual chatbots over omnichannel to quickly respond to your customers 24/7.
Learn More
Qwen
Full-range, open-source, multimodal, and multi-functional
Learn MoreMore Posts by Alibaba Cloud Native Community
