How to Use Claude Ultrareview for Code Review

Claude Ultrareview is an extended review capability in Claude Code that examines a set of code changes against your requirements and produces a list of findings: potential defects, deviations from the original plan, and patterns worth flagging. Like any automated review, its output is a list of questions to investigate, not a verdict. Tools like fenbs store the confirmed defects and lessons so future sessions start with that knowledge rather than discovering the same issues again.

The benefit of an extended review mode over a plain "review this code" prompt is depth and consistency. Ultrareview applies a more thorough inspection pass, checking things a quick prompt might skip: edge cases, error handling paths, adherence to the constraints in the task.

How to verify that Ultrareview is available

Ultrareview availability depends on your Claude Code subscription and version. Check the Claude Code documentation↗ (opens in a new tab) for the current list of features at each tier. If Ultrareview is not listed in your session options, the feature may require a subscription change or a version update.

To confirm it is working, run it on a small, recent change you understand well. If the output is a structured list of findings rather than a brief comment, Ultrareview is active.

How to bound the review before invoking Ultrareview

An unbounded review of a large codebase produces many findings, most of which are not relevant to the change you made. Before invoking Ultrareview, scope it clearly.

• Tell it which files or commits are in scope.
• Provide the original task requirements or the approved plan the change was supposed to implement.
• List anything the review should not flag: intentional deviations you already approved, known technical debt, out-of-scope patterns.
• State the review's goal: is this a correctness check, a security review, a conformance check against a plan, or all of the above?

A well-scoped review finds more actionable issues per finding than a broad one. It also produces output that is faster to triage.

How to validate Ultrareview's findings

Read each finding and decide whether it represents a real defect, an acceptable tradeoff or a false positive. Ultrareview is not always right. A finding that says "this function does not handle a null input" is worth investigating; whether it is a defect depends on whether null is a valid input in your context.

For each confirmed defect, create a task. For each false positive, note it so you can give better scope boundaries next time. For anything that is "technically true but intentional," record the decision so the next reviewer does not flag it again.

Do not pass Ultrareview's findings directly to Claude for automatic fixing without reviewing them first. A finding that is acted on without validation may introduce a change that was not needed, or fix a symptom rather than the cause.

Turning confirmed defects into lessons

If Ultrareview surfaces a class of issue that appears more than once across a review, that is a pattern worth recording. "Error responses from the payment API were not consistently handled" is more useful than a list of individual instances. Record the pattern as a lesson so future sessions check for it before submitting a change.

Lessons stored in fenbs are read by connected assistants before similar work. If the next session is working on payment handling, it reads the lesson before writing the code, not after.

Working with a large volume of findings

A large changeset can produce a large number of findings. Before working through them individually, group them by type: null handling, error propagation, naming consistency, deviation from the plan. Grouping reveals whether you are looking at many instances of one underlying issue or genuinely many different issues. One root cause is faster to fix than a dozen separate defects.

Prioritize findings that could affect correctness over findings that affect style or naming. A potential null dereference in a payment flow is more urgent than inconsistent variable naming in a utility. Work through the correctness issues first, create tasks for the important stylistic findings, and note the intentional choices so they do not keep appearing in future reviews.

When Ultrareview is not the right tool

Ultrareview examines code text. It cannot run your test suite, observe runtime behavior, or catch issues that only appear under load. Use it as one layer in your review process, not as a replacement for tests or manual review of behavior.

For small changes in familiar territory, a plain "review this diff" prompt may give you what you need faster. Reserve Ultrareview for larger changes or for code paths where thoroughness matters more than speed.

How to do this with fenbs

1. Create a free account and add the project. Record the coding standards and review criteria as Decisions and rules so every assistant knows what "correct" means for this codebase.
2. When you finish a change, add or update the task in fenbs. Include the acceptance criteria the change was supposed to satisfy.
3. Connect Claude Code over MCP from Integrations. Invoke Ultrareview with the task requirements and the file scope as context.
4. For each confirmed finding, create a new task. For recurring patterns, add a Lessons learned entry linked to the task.
5. Update the original task with the review result: what was confirmed clean, what was filed as a new task, and what was intentional and noted.