AI code review or verification against the spec?
AI code review reads code once it's written. Verification checks it against what was decided. A one-cent VAT rounding change shows why you need both.
October 15, 2026 · 6 min read
Plenty of teams added AI code review to their pull requests once generated code started piling up. Good call. It answers one question well. There’s a second question it was never built to answer, and a one-cent rounding difference on an invoice is a good way to see it.
Two questions about the same diff
AI code review tools, CodeRabbit and others, read code after it’s written. They comment on the pull request line by line, much as a senior colleague would, and they keep up when the volume of changes outgrows what people can read carefully. They live inside the normal developer workflow and look at what’s being proposed.
Verification against the spec starts somewhere else. It begins with intent, meaning the business rules, user journeys and invariants the software is supposed to respect. Then it checks that the shipped code respects them, rule by rule.
Same code, two questions. Review asks whether the code is well written. Verification asks whether it does what was decided. Code can be elegant and wrong. It can also be clumsy and fully compliant. Since the answers are independent, you need both.
Timing differs as well. A review comments on a change that already exists, after the design choices are made and the developer has moved to the next ticket. Verification can begin while the change is still a description, which shifts what you catch and how much it costs to fix.
Following one invoice through both
Take a billing module. The spec holds a plain rule: VAT is computed on each invoice line, rounded to the cent, and the invoice total is the sum of the rounded lines.
A developer, working with an assistant, adds support for a reduced VAT rate on some products. Along the way, the assistant tidies the tax code. Instead of rounding each line, it sums the lines and rounds the VAT once, on the total. Fewer loops, fewer rounding calls, nicer code. On most invoices nothing changes. On an invoice with three lines of €3.33 at 20% VAT, the old code charged €2.01 of VAT and the new code charges €2.00.
A review, human or automated, has every reason to approve. The diff is cleaner than what it replaced. The tests pass, because the test invoices happen to use round amounts.
To see the problem, you need to know the rule says per line. That isn’t in the diff. It lives in the business intent, somewhere in a spec page, an accounting requirement or a conversation with finance two years ago. A reviewer works with what it’s shown, and without the reference there’s nothing to compare against.
Now suppose the sources disagree. The spec page says round per line. The accounting export recomputes VAT on the total. One older code path uses banker’s rounding instead of rounding half up. Which one is right? A reviewer shouldn’t guess. Finance should decide, before anyone touches the code.
Stable answers for compliance questions
A second difference is structural. AI code review runs on a language model. Its comments are useful, yet two passes over the same code can produce different remarks. Fine for suggestions. Awkward when the question is whether VAT is still computed the way your accountant expects.
Developers feel this already. In the Stack Overflow Developer Survey 2025 (49,000 respondents), 29% said they trust the accuracy of AI output, down from 40% in previous years. Checking one model with another stacks a second probability on top of the first.
The Lyriks engine is deterministic. It’s built on graph rewriting, developed in-house, and is patent pending. No AI sits in the verification loop. Ask the same question of the same code and the same spec, and you get the same answer every time. That’s why a compliance report can hold up in front of a finance team, with every affected rule marked compliant, addition, omission or regression.
AI still has a job here, on the writing side. The approved spec goes to your LLM over MCP, with its rules and their sources. The engine checks the result, and each gap returns to the LLM until every rule holds.
Reading both outputs on the VAT change
Run the reduced-rate pull request through both layers and compare what comes back.
The review comments are about the code. It might suggest moving the rate lookup into its own function, point out a missing null check on the product category, and approve of the simpler loop. All fair. None of it mentions rounding, because nothing in the diff says rounding was ever a rule.
The verification report is about rules. Per-line rounding comes back as a regression, tied to the function that now rounds on the total. The new reduced rate shows as compliant for the products listed in the spec. If the assistant also applied the reduced rate to shipping fees, which nobody asked for, that shows up as an addition, waiting for finance to keep it or reject it.
Two outputs, two audiences. The developer acts on the first. Whoever owns the invoicing rules acts on the second.
Mixing up the two layers
The most common mix-up, in our experience, is reading a green review as proof of compliance. A review that found nothing means the reviewer found nothing in what it read. It says little about rules that weren’t in the diff, like per-line rounding.
The opposite happens too. Some teams, once they verify against a spec, start to wonder whether review is still worth the effort. It is. Verification won’t tell you a function is unreadable, that a query will crawl at scale, or that a variable name will confuse the next person. That’s review’s job.
A quieter one is running verification only after the code exists. By then the disagreement between the spec page and the accounting export has already been coded one way or the other, and someone has to unpick it.
Placing each one in the cycle
Review happens once, at the pull request, and looks at quality.
Lyriks steps in twice. Before implementation, when the reduced-rate change is described, it works out what the change touches, what fits the existing system, what conflicts and what still needs a decision. The rounding disagreement shows up there, while it only costs a conversation with finance. After implementation, the shipped code is checked against the spec, rule by rule.
So run both, each on its own question. The Verify AI code page shows how verification slots into a workflow that already has review.
Most teams already have the first layer. The second is the one that knows how your invoices are supposed to round, and you can try it on your own billing module in a demo.