Skip to content

· 7 min read

Make the code a little uwu

AI reviewers can find real bugs and still need a better second question. Build the adversarial pass into the skill, then leave some room for cute, slightly embarrassing taste.

A tabby kitten with a terracotta ribbon inspects a brass gear through a magnifying lens beside a watchmaker's bench.
Illustration generated with GPT Image

The part of AI code review that bothers me is how often the useful second pass begins with two words: be adversarial. The first review can look reasonable. Then I ask the agent to push against the implementation, and it starts finding assumptions it had previously walked past.

I take that as a workflow problem. If that is the question I keep asking, it belongs in the review skill. Remembering to be more demanding after every pleasant first answer is a silly job to keep for myself.

The vendors have noticed the review problem too#

OpenAI's December 2025 article, A Practical Approach to Verifying Code at Scale, describes a reviewer trained for that job, with repository access and code execution. Its priorities include keeping false alarms low enough that developers continue reading the comments. The post reports that 52.7% of reviewer comments led authors to change code. That measures a response to comments; it does not tell us what fraction of all bugs the reviewer found.

Anthropic's March 2026 Code Review announcement describes agents finding potential bugs, verifying them, and ranking what remains. It reports an internal rise from 16% to 54% of pull requests receiving substantive review comments. The article supplies no sample size or enough methodology to turn that into a general estimate of review accuracy.

Those are different measurements, so I would not put them in a vendor leaderboard. They do make review worth taking seriously. The useful common idea is that producing a suspicion and establishing a defect are separate pieces of work.

Tool access also matters. Anthropic's current managed-review documentation says its reviews do not build or run the code. A local review skill with an executable checkout can attempt a reproduction. The product name alone tells me less than knowing what the reviewer actually inspected and checked.

Give the adversary something to do#

A request to be harsher can produce more objections. I want a better search instead. Ask for the input that violates an assumption, the event order that exposes stale state, or the failure path that leaves a resource alive. Then make the reviewer try to defeat its own finding.

Suppose a cache key drops a configuration field. A useful review traces two calls with different configurations to the same key and shows why their results can differ. It should also check whether an earlier layer already separates those calls. That last check can turn an alarming comment into a discarded hypothesis, which is a perfectly good outcome.

  1. Understand

    Recover the intended behavior and its constraints.

  2. Challenge

    Construct a concrete way the change could fail.

  3. Verify

    Check the surrounding code and try a reproduction.

  4. Report

    Keep distinct findings supported by evidence.

A proposed review procedure. A candidate can disappear during verification; the process does not require a quota of bugs.

A fresh reviewer can help change perspective. Give it the diff, the task, and the relevant repository context. Let it form its own explanation before handing it the author's reassuring summary. I would use that separation to loosen the influence of the author's explanation. Two agents can still overlook the same thing.

Put the procedure in the skill#

I would keep the main skill short enough to read. OpenAI's skill documentation explains that the name and description help select a skill, while the full instructions load when it is used. A clear trigger matters as much as an impressive checklist hidden underneath it.

A small review SKILL.md to adapt
---name: review-changedescription: Review a proposed code change for actionable defects.---Read the requested behavior, diff, and repository instructions.Trace changed assumptions through callers and relevant tests.Make a second, adversarial pass:find a concrete input, event order, or failure that breaks the change.Try to disprove each candidate finding using the surrounding code.Run a focused reproduction when the environment permits it.Report the location, trigger, consequence, and supporting evidence.Distinguish introduced defects from pre-existing issues.Deduplicate findings. Separate taste suggestions from defects.State what was not checked. No findings is a valid result.

The repository can supply the details this template lacks: important invariants, the command for a focused test, and examples of defects worth reporting. An ownership rule needs its actual lifetime boundary. A compatibility rule needs the supported versions. A wall of instructions to consider every possible concern gives the reviewer much less direction.

I would evaluate the skill on old changes with known bugs and on clean changes that resemble them. Keep the model, tools, and budget comparable. Count confirmed defects, false alarms, time spent verifying comments, and bugs discovered after the review. Anthropic's skill guidance also recommends fresh-session comparisons with the skill available and disabled. The skill needs to improve the work, including when it should stay out of the way.

My answer to how much you should care is: enough to make a useful review routine and measure its value. Spend more attention on changes to ownership, persistence, and cross-module assumptions. Keep the budget small for a small, easily checked edit. An empty report means the reviewer found nothing it could substantiate within that pass. The tests and the engineering judgment still have work to do.

Then there is the uwu factor#

My less respectable prompting observation is that uwu, placed near the words code quality, works mysteriously well. I mean that as an observation about my own prompts and taste. I do not have a controlled result showing that the word improves code or finds more bugs.

Still, I like what it asks for. Small. Approachable. A little embarrassing to make grand claims about. When I ask for elegant code, I sometimes get an architecture that wants me to admire it. A cute solution can be a plain loop that fits on the screen and knows when to stop.

My guess is that an odd word can loosen the usual associations around a request. The practical move is to attach it to concrete preferences so the result has something to answer to.

An optional taste pass after checking behavior
Make the code quality a little uwu.Small, direct, easy to hold in my head.Look for an abstraction we can delete or a state we can stop tracking.Keep the behavior and the useful names.Show the smallest worthwhile change and how to check it.

A taste pass should earn its diff. Show the state that disappears, the call chain that becomes shorter, or the name that makes the operation clear. Preserve the useful test and check the behavior again after changing the implementation. Adding baby talk to comments is unlikely to help any of this.

I would keep these questions distinct in the output: what can break, and what could become easier to understand? The first needs a failure case. The second needs a convincing before and after. Calling both of them critical findings would make the review harder to trust.

Maybe code should be allowed to be cute and a little cringe. A small function with obvious data flow can survive that indignity. I still want the adversarial reviewer to check whether it works.