Back to index
OtherSelf-paced, set up in under an hour·Free starter tier for one developer, Pro $30 per seat a month

Greptile AI Code Review

4.2

The best of the AI code review tools I have used, because it reads the codebase rather than the diff. The free tier is genuinely usable, custom rules in plain English work better than they should, and the learning from team comments is the feature that earns the subscription.

What We Liked

  • Graph indexing the repository means it catches multi-file logic bugs, not just style
  • Custom rules written in plain English are far more practical than a linter config
  • It learns your team's standards from review comments over time
  • Free tier for a single developer with unlimited repositories is unusually generous

What Could Be Better

  • Credit-based pricing makes cost hard to predict on a busy repository
  • False positives are still frequent enough to train people to skim
  • TREX test generation costs three credits per run and the tests need review
  • GitHub and GitLab only, which excludes a lot of enterprise setups

Detailed review

Almost every AI code review tool fails the same way. It reads the diff, notices that a variable name is unclear or that you have not handled a null, and leaves a comment. This is useful roughly twice before your team learns to scroll past it. The reason is that the diff is the wrong unit of analysis.

Real bugs in real codebases are relational. You changed a function's behaviour and three callers elsewhere depended on the old behaviour. You added a field and a serialiser in a different module now silently drops it. None of that is visible in the diff, which is exactly why human reviewers who know the system catch things that human reviewers who do not cannot.

Greptile's answer is to build a graph index of the whole repository and give the reviewing agents access to it, and the result is a tool that occasionally catches the relational bug. Not always, and I want to be measured about this rather than breathless, but often enough that I stopped reflexively dismissing its comments, which is the single highest bar in this category. The custom rules feature deserves specific praise. You write rules in plain English, things like the rule that all database queries in the billing module must go through the audit wrapper, and it applies them.

This is the thing every team wants from a linter and cannot have, because encoding a rule like that in a static analysis config is either impossible or a week of work. Here it is a sentence. I have found this to be the feature that converts sceptics. The learning mechanism is the other genuine differentiator.

It watches what your team comments on during review and adjusts. Over a few weeks it stops flagging the pattern your team has collectively decided is fine and starts flagging the thing your senior engineer always complains about. This is slow and unglamorous and it is also exactly right, because a codebase's standards are mostly tacit and live in people's heads rather than in a document. On pricing, the free starter tier gives one active developer unlimited repositories and 50 credits a month, where one credit is a standard review.

For a solo developer or someone evaluating, that is real and not a crippled demo. Pro is $30 per seat monthly with 50 credits per seat and extra credits at a dollar each. My reservation is that credit-based pricing on a busy repository is genuinely hard to forecast, and a team that merges forty pull requests a week per developer will blow through the allowance and not know until the bill. Work out your merge rate first.

TREX, the agent that writes and runs tests for a pull request, costs three credits per run and produces tests that need reviewing like any other generated code. It is a reasonable feature and not a reason to buy. False positives remain the honest weakness. It is better than its competitors and it is not clean, and the failure mode of any review tool is that people learn to skim.

Watch for that on your team and prune the rules that generate noise. Free for qualifying open source projects and discounted for pre-Series A startups, which is a decent posture. Four point two. The one in this category that actually reads your code.

[ final ]

The verdict.

The one I would actually pay for in this category. Treat it as a second reviewer that never gets tired, not as a replacement for someone who understands the system.