Complete Greptile Review (2026)

Greptile is an AI code reviewer that uses a graph of your repository to follow connections between files, functions and dependencies. It is most relevant when a small change can break code elsewhere, such as a shared API or a library used by several services.

I would shortlist Greptile for a team struggling with cross-file bugs. For a small, well-tested repository, the extra context may add less value. I have not run a new hands-on Greptile test. Our best AI code review tools guide separates the tools we run from those we assess through published information.

Greptile at a Glance

Before subscribing to Greptile, check the current plan limits and whether it supports your Git provider.

Area	Current Position	Buyer Check
Review method	Repository graph plus diff	Cross-file findings
Providers	GitHub and GitLab apps	Your exact provider
Free entry	Starter, one developer	Active-developer limit
Paid price	US$30 per seat monthly	Seats each billing period
Usage meter	Credits per review	Review depth and reruns
Enterprise	Self-hosting and compliance	Contract details

How Does Greptile Review Your Code?

Greptile reviews pull requests using an index of the repository's files, functions and dependencies. On a pull request, the product uses that graph to review the change with repository context and posts comments with suggested fixes. Its overview says typical findings arrive in about three minutes.

Test a change that affects code in another file. Imagine a handler changes the shape of a result, while a background job and a client library consume that result elsewhere. A diff-only reviewer may only see the handler.

Greptile also says reactions and replies teach it what a team cares about, with less unwanted feedback after two to three weeks. That is a vendor product claim, so validate the behaviour on your own repository.

Who Should Use Greptile?

Greptile best suits teams reviewing changes across shared libraries, services or packages, where the affected code is hard to see in one diff.

A small repository with clear tests may still benefit from a second reviewer, but there may be fewer hidden dependencies to find. Try it on changes where understanding related files could reveal a missed bug.

How Much Does Greptile Cost?

Greptile's pricing page lists a free Starter plan for one active developer with 50 monthly credits, and a Pro plan at US$30 per seat per month with 50 credits per seat.

A Base review uses one credit, Plus uses three and Apex uses ten. Additional credits cost US$1 each, so deeper reviews can use the included allowance much faster.

Greptile's published plans. Confirm before any purchase.

Plan	Price	Included Credits
Starter	Free, one active developer	50 each month
Pro	US$30 per seat monthly	50 per seat
Extra credits	US$1 each	Bought as needed
Enterprise	Custom pricing	Negotiated

The same page lists a 14-day trial for Pro, unlimited repositories, custom rules, and external-app connections. It presents Enterprise as custom pricing with self-hosting and compliance options. Prices, credit rules, discounts, and plan features are volatile, so confirm them on the official page before a purchase or a budget approval.

Greptile's changelog says a free individual Starter tier launched June 29, 2026. The pricing page also says qualified non-commercial projects with an OSI-approved open-source licence can apply for free service and eligible early-stage startups can apply for a discount.

How Should You Test Greptile?

Test Greptile on one repository using known cross-file defects and compatible changes that should produce no warning. The AI reviewer trial method explains how to record the results. Choose a pull request where a changed type, schema, or authorisation helper has a known consumer outside the diff.

1. Name the changed symbol and the dependent path before the review runs.
2. Keep the known contract failure hidden from the review prompt.
3. Check whether Greptile identifies the dependent and explains the broken behaviour.
4. Repeat with a compatible change that should produce no finding.
5. Record which bugs required reading related files and which were visible in the changed lines alone.

How Does Greptile Learn from Feedback?

Greptile learns team preferences from reactions and replies to review comments. Consistent feedback helps it distinguish a useful finding from a suggestion your team does not want. For a Greptile comment, establish whether the behaviour is reachable, add a test or inspection note that explains the decision, and react consistently. A confirmed defect gets fixed with reproducible evidence.

A false positive gets a concise, evidence-backed dismissal. Assign an owner to useful work you defer rather than leaving it in an unresolved thread.

Greptile's documentation describes thumbs-up and thumbs-down reactions plus replies as inputs to its learning loop. That creates a reason to avoid casual reactions. If different reviewers signal different priorities, the tool may learn conflicting preferences.

Agree on a few categories first: correctness, security, contract compatibility, test coverage, or out of scope.

Comment Result	Reviewer Action	Evidence
Confirmed defect	Fix and react	Failing path or test
False positive	Dismiss and explain	Guard or contract
Deferred concern	Create owned work	Scope decision

How Do You Verify Greptile Findings?

Verify a Greptile finding by tracing the changed code to the affected caller and checking whether the reported failure can occur. Look for a comment that names the changed function or value, the code that uses it, and what would break. Then follow that named path through the repository.

If the comment cannot identify the caller, contract, or state transition involved, treat it as a question for a reviewer. It is not yet a defect ready for repair.

Use a small change set for the first tests. A renamed field that is consumed by a serialiser, a changed error type handled in another package, or an authorisation helper used by several routes can all show whether the repository graph adds useful context.

Include the existing relevant tests in the inspection. A true cross-file issue should either change a test result or expose why no test covers the affected contract.

• Trace the comment from the edited line to every named dependent.
• Check whether a type, validator, or adapter preserves compatibility.
• Confirm the affected consumer can receive the changed value at runtime.
• Add a regression test that crosses the same boundary.

How Do You Configure Greptile?

Configure Greptile with a .greptile/ folder containing review settings, plain-language rules and references to relevant project files. Place the folder at the repository root or inside a directory. Settings cascade from root to leaf, while rules and file references accumulate across the matching folders.

The recommended folder supports three optional configuration files. config.json holds documented review settings and structured rules. rules.md holds plain-language instructions scoped to that directory.

files.json points Greptile at existing schemas, API specifications, or architecture documents.

.greptile/
├── config.json
├── rules.md
└── files.json

// .greptile/config.json
{
  "strictness": 2,
  "rules": [
    {
      "id": "tenant-writes",
      "rule": "Trace authenticated tenant ownership to every data write.",
      "severity": "high"
    }
  ]
}

// .greptile/rules.md
## Contract changes

Flag a changed public response shape when no contract test covers it.

// .greptile/files.json
{
  "files": [
    {
      "path": "docs/architecture.md",
      "description": "Service boundaries and ownership"
    }
  ]
}

A nested folder can override scalar settings, disable an inherited structured rule by its ID, and add local rules or context files. Keep the current .greptile/ reference open while editing these files. Greptile still supports greptile.json for backward compatibility, but .greptile/ takes precedence when both exist in one directory.

Local configuration is useful when the repository has meaningful boundaries. An API directory can ask for authorisation tracing, while a payment module can ask for idempotency and error-path review. Write rules that describe behaviour you can check, rather than copying your whole engineering handbook into the prompt.

Can Greptile Hand Fixes to Coding Agents?

Greptile can use Fix in your IDE on a review comment to send the file, line numbers, review comment, and suggested fix to Claude Code, OpenAI Codex, Conductor, Cursor, or Devin. It also documents a separate Fix All action.

An agent handoff is a convenience for a confirmed finding, not proof that the proposed patch is correct. Read the complete review finding before assigning the repair. Inspect the generated diff against the confirmed failure path.

Run the relevant test suite and project checks. Then request a fresh review only if the repair changed the path that prompted the comment. This sequence keeps the human reviewer responsible for the code that merges.

What Are Greptile's Main Limitations?

Greptile can still miss dependencies, misunderstand project requirements and produce false positives. Its repository graph gives the reviewer more context; it does not prove a finding is correct. Hosted plans centre on GitHub and GitLab, while Enterprise lists additional self-hosted providers and deployment options.

Finally, settle the cost question from your own pull-request volume. Credits show the charge for a run. The full cost also includes checking comments, making fixes and rerunning reviews. The CodeRabbit guide and BugBot guide show other review workflows to test against the same rubric.

The Case for a Greptile Trial

Judge Greptile by the bugs it catches across related files. Give it contract breaks that ordinary diff review misses, require every comment to identify the dependent path, and use .greptile/ to supply only the context needed for that proof. A team with mostly compact, well-tested repositories may gain little from the graph and may not need another reviewer.

Frequently Asked Questions

Does Greptile read the whole codebase?

Greptile indexes the selected repository and retrieves related files, functions and dependencies during a review. Indexing a repository does not mean every file is included in every model request or every dependency will be understood correctly.

Which Git providers does Greptile support?

Greptile offers GitHub and GitLab integrations on its hosted plans. Enterprise also lists GitHub Enterprise Server, GitHub Enterprise Cloud with data residency, GitLab Self-Managed, Bitbucket Data Center, Gitea and on-premises Perforce/P4. Check the deployment requirements for your chosen host.

Can Greptile send a fix to Codex?

Greptile can send a review finding, file paths, line numbers and a suggested fix to Codex through its Fix in your IDE action. Codex then handles the proposed change; a developer must still check the diff and relevant tests before merging.

Is Greptile free for open source?

Qualified non-commercial projects with an OSI-approved open-source licence can apply for free Greptile access. Greptile also offers a free Starter plan for one active developer with 50 monthly credits, subject to its current plan terms.

Keep Reading

• AI code review hub
• CodeRabbit guide
• BugBot guide
• Greptile vs GitHub Copilot