What changed in version 2.1.328
The changelog entry makes three changes to the local command, all on most models:
- Scope. The review now reports "only bugs and CLAUDE.md violations".
- Labels. Each finding is marked Important, Pre-existing, or Nit.
- Output. Each summary ends with a suggested fix. A review with nothing to report now says so in one line: Code review found no issues.
The qualifier "on most models" appears in both lines. The changelog doesn't list which models are excluded. If your review still includes cleanup suggestions after updating, the model you're using may be one of the exceptions.
Cleanup work hasn't disappeared. It has moved to a separate command, and the changelog names it: run /simplify for reuse, simplification, and efficiency cleanups.
Why the documentation still describes the older scope
On the day of the release, the local review page still opens with the older description: "Claude reviews the changes on your branch, looks for correctness bugs, and reports what it found in your conversation. Depending on your model and effort level, the review also covers reuse, simplification, and efficiency cleanups."
The commands reference has a matching line: "Depending on your model and effort level, the review also covers cleanup opportunities."
The changelog is the more recent source. It's also more specific, since it names the two categories that remain. When a release note and a documentation page disagree on the same day, the safe reading is that the page hasn't caught up yet. Check your installed version with claude --version and compare it to 2.1.328.
An earlier changelog entry shows how this has moved before. One release changed the review "at medium effort to also report cleanup and CLAUDE.md conventions findings on models without tuned review settings, including Opus 5.5 and Sonnet 5.5". The scope of /code-review has shifted with models and effort levels for a while. Version 2.1.328 narrows it on most models.
What Important, Pre-existing, and Nit mean
The changelog names the three tags without defining them for the local command. The managed Code Review service on GitHub uses the same three labels, and its documentation defines them:
- Important: "A bug that should be fixed before merging"
- Nit: "A minor issue, worth fixing but not blocking"
- Pre-existing: "A bug that exists in the codebase but wasn't introduced by this PR"
Pre-existing is the one most worth reading carefully. It's a real bug, but your change didn't cause it. That's useful for deciding scope: you can fix it now, or record it and handle it separately, without treating it as a blocker for your change. The changelog describes the tags as a change to the local command, so before this release a bug you inherited and a bug you introduced could sit side by side in the same list without that label.
Nit covers minor issues. On the managed service, teams can recalibrate what counts as Nit or Important through a review-only file. The local command reads a different set of files, covered next.
Which files the local review reads
This is where the change connects to your instructions. The local review page says: "the review follows your CLAUDE.md, including in a non-interactive -p run. It doesn't read REVIEW.md."
So for /code-review on your machine, CLAUDE.md is the documented place for project rules. The same page says so directly: "To give every review project rules to follow, add them to your CLAUDE.md."
With the new scope, that matters more. A CLAUDE.md violation is now one of the two things the review reports on most models. A convention you keep only in a team wiki, a pull request template, or your head isn't one of them.
The managed service's customization page draws the same line from the other side: "The service reads both CLAUDE.md and REVIEW.md. The /code-review command, which you run inside a Claude Code session on your own machine, reads your CLAUDE.md files and not REVIEW.md." Its advice: "Put guidance you want applied in both places in CLAUDE.md, and keep REVIEW.md for rules specific to pull request review."
For the service, the same page describes how CLAUDE.md is applied: "A change that violates one of their rules becomes a finding at whichever severity level fits the issue." It also says the service reads the root file and the CLAUDE.md files in the parent directories of each changed file.
When /simplify is the right command
/simplify is the cleanup counterpart. The commands reference describes it: "Review the changed code for cleanup opportunities and apply the fixes." Four review agents run in parallel, covering reuse of existing helpers, simplification, efficiency, and whether the change is at the right level of abstraction.
The same entry is explicit about the boundary: "The review doesn't look for correctness bugs. Use /code-review to find bugs."
There's a naming history that can trip up scripts. The local review page says: "The command was named /simplify before v2.1.147, when it applied fixes by default. If you scripted /simplify for bug-finding, switch to /code-review --fix."
So the split is now clean:
/code-reviewfinds bugs and CLAUDE.md violations, and reports them./simplifyfinds cleanup opportunities, and applies the fixes.
Run them in either order. A reasonable habit is /code-review first, so correctness issues are fixed before cleanup reshapes the code.
Choosing what to review
With no target, the local page says, "/code-review reviews your branch's commits ahead of its upstream branch plus your uncommitted changes." If the branch has no upstream, it compares against main or the previous commit.
You can point it elsewhere by typing a target after the effort level and any flags. The documented targets include a pull request number, a branch compared with another, a commit range, and a file or directory path. A path is useful when you want the new scope applied to one area, such as a module whose CLAUDE.md has its own rules.
To post the results instead of reading them in the terminal, --comment "posts the findings on a GitHub pull request as inline comments, or on a GitLab merge request as a single note". Those comments carry the same tags, which makes the Pre-existing ones easy to spot in a pull request thread.
When Claude starts the review for you
You don't always type the command yourself. The local page lists two ways Claude can start it. The first is when you ask in plain language: "ask Claude to review your changes and it can run the skill". The second is a session-scoped scheduled task whose prompt is /code-review.
Both runs use the same scope as a typed command, so a scheduled review now reports bugs and CLAUDE.md violations too. If you'd rather keep the command for manual use only, the page describes a skillOverrides entry in a settings file that makes the skill user-invocable only. It stops Claude and scheduled tasks from starting the review while keeping the command available to you.
Changing or replacing the review
/code-review is a bundled skill. The page explains what that means: "its instructions are built into Claude Code, so there is no SKILL.md file on disk to open or edit."
If the new scope doesn't suit your team, you have documented options. The page says that "a project or personal skill named code-review runs in place of the bundled one, and the /review alias keeps running the bundled review." You can also write a reviewer subagent or a review skill of your own.
Before replacing it, consider the simpler route the page points to first: put the rules in CLAUDE.md. The bundled review already follows that file, and with the narrower scope, a clear rule there is more likely to surface as a finding than a long list of preferences.
Writing rules a review can check
A CLAUDE.md violation is easiest to report when the rule is specific. A line that says a directory must never be edited by hand, that every API route needs a given middleware, or that tests must not touch a production database gives the review something concrete to compare against.
Vague preferences, such as keeping code clean, are closer to what /simplify handles. Keeping those out of CLAUDE.md also keeps the file short, which helps every task Claude reads it for, not only reviews.
How the local review runs
A few details from the documentation help you read the results.
It runs in the background. "In a terminal session, the review runs as a background subagent with its own context window, so it doesn't fill your conversation. The findings arrive in your conversation when the review completes."
It reports unless you ask for fixes. Without --fix, the page says, "the review's instructions ask Claude for a report only." With --fix, edits still go through your permission mode.
Rewind has limits after a background fix. The page says that a background review applies its --fix edits outside your session's checkpoints, and that /rewind restores only files Claude had already edited in your conversation. Its advice for the rest is to use git.
Effort changes coverage. "At low, the review reports the findings it's most confident in, so you see fewer false positives. From medium through max, the review broadens coverage." When you don't type a level, the review reuses the last level you typed, even from an earlier session.
The desktop app shows a list. In a host application that asks for structured results, such as the desktop app, the page says each entry "shows the file location, a one-sentence summary, and a category tag". Fixes are tracked too: "When Claude fixes reported findings later in the session, it reports them again. Claude Code then marks each finding in the updated findings list as fixed, skipped, or no change needed." That status list is useful while you work, and it lasts as long as the session does.
Findings have a limit. You can raise or lower it with --max-findings, and where the review reports through the findings tool, the documented limit is 32.
How it differs from Code Review and ultrareview
Three review tools share a name, and the new scope applies to only one of them.
/code-reviewruns locally in your session, reads CLAUDE.md, and now reports bugs and CLAUDE.md violations on most models.- Code Review, the managed service, reviews pull requests on GitHub for your organization and reads both CLAUDE.md and REVIEW.md.
- Ultrareview, started with
/code-review ultra, runs a deeper review in the cloud.
The local page says /review is an alias of /code-review, so the change applies to both names.
We covered the cloud option, including what it uploads and where findings come back, in our guide to ultrareview in Claude Code.
What people try first
Looking for cleanup suggestions in /code-review. On most models, they've moved to /simplify.
Putting review rules in REVIEW.md for local reviews. The local command doesn't read it. Use CLAUDE.md.
Treating every finding as blocking. On the service, Nit is defined as not blocking, and Pre-existing as not introduced by the change.
Trusting the docs page over the changelog today. The page still describes the older scope.
Using /simplify to find bugs. It doesn't look for correctness bugs.
The Fix: Make CLAUDE.md carry your review rules
Step 1: Update and check your version
Run claude --version. The new scope arrived in 2.1.328.
Step 2: Move review-relevant rules into CLAUDE.md
Conventions that only live in a wiki or a template aren't in the files the local review reads.
Step 3: Split your review habit
Run /code-review for bugs and rule violations, then /simplify for cleanup.
Step 4: Record Pre-existing findings you decide to defer
Write down which ones you left, why, and where they live.
Setting this up in MemoryLake
CLAUDE.md is where Claude Code reads project rules, and keeping it short is part of using it well. Some context doesn't belong there: why a rule exists, which Pre-existing bugs you chose to defer, which areas keep producing the same finding, and what you decided after a review.
MemoryLake is a memory layer for that kind of project context, such as review decisions, deferred issues, and the reasons behind your rules, kept in one place you maintain and available to the assistants you connect, such as ChatGPT, Claude Code, and Codex.
You write the entries yourself, in your own words. Nothing is read out of, written to, or deleted from your CLAUDE.md files, your Claude Code sessions, your review findings, your repositories, or any vendor's store. Claude Code's review works the way Anthropic describes it.
Step 1: Create an API key
Sign in and generate a key from the dashboard. Store it outside your repositories, like any other credential.

Step 2: Upload your first memories
Start with what you wrote in Step 4 of the fix: deferred findings and the reasons. One decision per entry.

Step 3: Connect your AI & agents
Connect Claude Code, Codex, and the other assistants you use. The next review or fix can start from the same decisions.

What this changes in practice
The first difference is fewer repeated findings. A deferred Pre-existing bug is on record with its reason.
The second is a leaner CLAUDE.md. Rules stay there, and the history behind them lives elsewhere.
The third is consistency across tools. The same review decisions are available in Claude Code and in other assistants.
Best practices for /code-review
Know your version. The scope change arrived in 2.1.328.
Keep rules in CLAUDE.md. It's the file the local review follows.
Use REVIEW.md only for the managed service. The local command doesn't read it.
Read the tags. Important should be fixed before merging, Nit isn't blocking, and Pre-existing wasn't introduced by your change.
Run /simplify for cleanup. It applies fixes and doesn't look for bugs.
Choose effort on purpose. Low favors confidence, higher levels broaden coverage.
Use git after background fixes. Rewind doesn't restore every file a background review edited.
Conclusion
Claude Code 2.1.328, released on November 19, 2026, narrows /code-review on most models to bugs and CLAUDE.md violations, marks each finding Important, Pre-existing, or Nit, and ends each summary with a suggested fix. Cleanup moved to /simplify, which applies fixes and doesn't look for correctness bugs. The local documentation page still describes the older scope, so check your version against the changelog.
The local review follows CLAUDE.md and doesn't read REVIEW.md, which the managed service uses. With the new scope, your CLAUDE.md is one of the two things the review checks, so rules you want enforced locally belong there. Keep the reasons and decisions behind them somewhere that outlasts a single review.