Everything worthchecking. In order.

You cannot judge whether an implementation is correct against an intention you never stated. This is also the single input that changes a review's output most.

They fail differently. Generated code is idiomatic and lint-clean, so the mistakes that survive in it are semantic rather than structural.

Almost every security item below is really a question about what happens to untrusted input, and you need to know which input that is.

A wrong pricing function and a wrong log message deserve different amounts of your attention. Decide that before you spend it.

Validation on one path and not another is the common shape. Follow the sink backwards, not the input forwards.

A check that runs after the write has already happened is not a check. Missing function-level authorisation is a top-ten class on its own.

Trusting a client-supplied user id is how broken object-level authorisation reaches production, and it reads as perfectly normal code.

The log line is the one people miss. A token that never touches disk still leaks if it is printed on failure.

Stack traces, query fragments and library versions in a response are reconnaissance handed over for free.

Both are remote code execution and open redirect respectively, and both look like ordinary plumbing.

Path traversal is still one of the most reliable ways out of an upload directory.

A token generated from a general-purpose random source is predictable, and nothing about the code will look wrong.

A default of none means one slow dependency holds your connections until the pool is empty. Down is easy, slow is what takes systems out.

An uncapped retry loop turns a small upstream problem into a self-inflicted denial of service.

A catch that logs and continues with a null is often worse than a crash, because the corruption surfaces somewhere unrelated.

Connections, file handles and locks leak from the branch nobody tested.

Retries, webhooks and queue redelivery all mean at-least-once. Anything that charges money needs an idempotency key.

Read-modify-write without a transaction or a lock is a race that passes every test and fails under real traffic.

This turns the review into a comparison rather than a guess. It is the only way to catch a function that computes the wrong number with no defect in the code.

Discount before tax and tax before discount are both plausible code and different money.

Whether a threshold is inclusive is a business decision. The code will happily encode either one.

Rounding at each step instead of at the end is a real and recurring source of money going missing.

A negated condition is syntactically perfect and semantically backwards, and it reads correctly at speed.

Generated code is frequently correct for the case described in the prompt and wrong for the two that were not mentioned.

The N+1 pattern is invisible at development volumes and is the most common cause of a page that got slow without anyone changing it.

Selecting everything moves data you will discard, and it hides which columns actually need an index.

A sequential scan is correct, which is exactly why nothing reports it as an error.

Three awaited calls that do not depend on one another take three times as long in sequence for no reason.

Compiling, parsing and configuration building inside a handler is a cost paid on every call forever.

Reading a whole table or a whole file works until the day the input is large, and then it fails everywhere at once.

A function that does two things has to be understood twice every time anyone reads it.

The person reading it at three in the morning is the audience, and they have no context you have now.

The code already says what. Generated code is particularly prone to comments that restate the line above.

GitClear measured an eightfold rise during 2024 in blocks of five or more lines duplicating adjacent code. Duplication is the specific way AI-assisted code accrues debt.

Every one of them is a thing a future reader has to prove is unnecessary before removing it.

An escape hatch at an interface propagates outward, and the failure lands somewhere far from the cause.

A change can be individually clean and still be wrong for the system. No line-level review of any kind will tell you this.

A test that passes either way documents nothing and protects nothing.

A migration that drops a column and a deploy that cannot be reversed are decisions, and they should be made deliberately rather than discovered.

If the honest answer is no, that is the finding. Shipping code nobody understands is the actual risk in AI-assisted development, and it is not a code-level defect at all.