Greptile

What do you like best about the product?

What I like best is that Greptile actually understands the full codebase, not just the diff. It builds a graph of how files, functions, and dependencies connect, so it catches cross-file bugs and regressions that other reviewers—and honestly even human reviewers—tend to miss. The natural language search is also a game changer for onboarding: instead of asking a senior dev, “Where is this logic handled?”, you can just ask and get a grounded answer with file paths. It’s also learned our team’s review style over time, so the suggestions feel more relevant with each PR. It genuinely feels like having a senior engineer glance over every PR without slowing down the merge cycle.

What do you dislike about the product?

What I dislike is the noise-to-signal ratio on larger PRs. Greptile does catch real bugs, but it also flags a lot of nitpicks and false positives. Sometimes it leaves 8–10 comments on a PR where only 2–3 are actually worth acting on, and that ends up training developers to skim the feedback or ignore the bot entirely. And it Only supports GitHub and GitLab, so if your team is on Bitbucket or Azure DevOps, it's not an option at all.

What problems is the product solving and how is that benefiting you?

Greptile solves the problem of code reviews being slow and inconsistent. Instead of every PR sitting in a queue waiting for a human reviewer who may not have full context on the codebase, Greptile flags cross-file bugs and edge cases as soon as a PR is opened. By the time a human reviewer takes a look, the obvious issues have already been addressed. The biggest benefits are faster merge cycles, smoother onboarding for new team members, and more consistent code quality regardless of who’s on the team or what time the PR goes out.

What do you like best about the product?

The GitHub integration with our repos and codebase gives it a wide array of context, instead of only looking at the context of pull requests. This is a big help when working on shared projects, because we don’t always have full visibility into how changes in other files might break dependencies. Greptile thinks through all of that in advance. The comments it leaves in PRs are also relevant, and the solutions it suggests are pretty sound. Overall, our whole SDK integrates very well with this.

What do you dislike about the product?

The prompt needs to be precise when working on a large project; otherwise, the generated output often isn’t very accurate. Filtering and narrowing down the issues can also be tough at times.

What problems is the product solving and how is that benefiting you?

It creates a detailed flow and trace of how our codebase is interconnected. We sometimes use it to explain things and transfer knowledge to team members, thanks to the intuitive way it presents what’s there. During reviews, the lightweight review modules also do a fairly good job. The main benefit we’ve found is during integration of different modules: it can pre-identify what might break where, and it stays mindful of those dependencies while generating output.

What do you like best about the product?

its deep understanding of the entire codebase rather than reviewing only the changed lines

What do you dislike about the product?

The main drawback is that deeper reviews can add latency and usage costs, particularly for larger or more complex PRs

What problems is the product solving and how is that benefiting you?

Understanding complex codebases in natural language and even development.

What do you like best about the product?

What I like most about Greptile is that it checks the full codebase instead of only PRs. This is really useful when working on large projects, where a change in some files can easily affect or break other modules. The UI is great and easy to follow, so it’s simple to understand the overall flow. The GitHub integration is also solid, especially for including it in the PR workflow, and the review comments are great detailed and helpful.

What do you dislike about the product?

I’ve noticed that deeper codebase analysis can sometimes take longer when it’s a large repo or when PRs are bigger. Also, some of the comments aren’t very actionable and require manual inference before I can make changes. I’d like more control over filtering issues, so the most important ones are easier to identify.

What problems is the product solving and how is that benefiting you?

The amount of manual effort it reduces when trying to understand changes in a large codebase is a huge plus, especially when you’re looking through related code and dependencies. The Q&A section for understanding the codebase is also very useful for tracing how the logic works, and it really helps speed up the process. It’s a real time saver during code reviews and makes it much easier to catch problems.

What do you like best about the product?

It actually understands the whole codebase, not only the line code changed. It actually makes a graph of my entire repo so it can tell after changes what affects my existing structure, so I can easily predict the consequences. It actually catches bugs, security issues, and also numbers the issues in a series. It also reads feedback and patterns we use, so it knows how we work, so it works better with time. It is already highly available and present in almost all IDEs and easily plugs into GitHub, GitLab, etc.

What do you dislike about the product?

I see one thing that while reviewing it takes a lot of time even if changes are smaller. I know it searches all code but it also needs optimization. Recent new pricing punishes us; it costs around 30 dollars per developer per month. If pull request volume increases, then it costs more than other competitors. They support through mail and Twitter, so there is no responsible person who listens to you, so your problem can take more time to resolve. It leaves more false comments which are not useful, but other things are good.

What problems is the product solving and how is that benefiting you?

It helps to reduce manual review and it doesn't only check what code changes, it compares with the whole codebase what happens if this change is made. So if any bug in my code can be easily detected, it saves more time. In the beginning, it leaves more comments, but with time it improves itself and reads our patterns and comments, so it works more efficiently over time. It focuses on what matters to our project, not the trivial ones. There is an agent I can connect with for any issue that arises; it sends that part to the agent so it gets corrected for me, so I don't need to go anywhere. It never misses any bugs yet; it reads each code with my codebase.

What do you like best about the product?

The GitHub integration is seamless, once the repo is connected, Greptile automatically triggers a review on every pull request without any manual steps. The setup process is straightforward, and the dashboard gives a clean overview of PR activity, review scores, and bugs caught over time. The keyboard shortcuts in the Pull Requests tab are a thoughtful touch for power users. I also appreciate that it works silently in the background, fitting naturally into an existing dev workflow without disrupting it.

What do you dislike about the product?

All three of my test PRs, including one with a Python file containing a deliberate division-by-zero bug and a JavaScript file with undefined functions and missing null checks, were scored 4/5 with a "Low" severity rating. While the reviews completed quickly, the consistent scoring across very different code quality levels raises questions about how granular the risk assessment actually is. There's no severity breakdown per issue, and the dashboard doesn't surface what specific bugs were caught without clicking into each PR individually. A summary view of flagged issues across all PRs would make the analytics far more actionable. The persistent payment banner during the free trial also feels premature.

What problems is the product solving and how is that benefiting you?

Greptile addresses one of the most time-consuming bottlenecks in software development, manual code review. In teams where senior developers are stretched thin, PRs often sit unreviewed for hours or days, slowing down delivery. Greptile acts as a first-pass AI reviewer that instantly flags potential bugs, risky patterns, and code quality issues the moment a PR is raised, without waiting for a human reviewer to be available. For my use case, it integrated directly with GitHub in minutes and began reviewing PRs automatically, no configuration per PR needed. The scoring system (out of 5) gives a quick at-a-glance signal of PR health, and the bugs-caught metric on the analytics dashboard helps teams track code quality trends over time. For L&D and non-engineering teams exploring AI-assisted development workflows, it lowers the barrier to maintaining code quality standards without needing deep technical oversight on every commit.

What do you like best about the product?

How much easier it makes working with a large unfamiliar codebase. Instead of spending ages digging through files trying to understand how everything connects, I can ask questions in a more natural way and get useful context quickly.

What do you dislike about the product?

That the quality of the responses can sometimes depend on how well I phrase my question.

What problems is the product solving and how is that benefiting you?

Mainly solves the problem of trying to understand unfamiliar or complex code without having to manually work through every file. When I need to understand how something works, where an issue might be coming from, or what could be affected by a change, it gives me a much quicker starting point

What do you like best about the product?

Reviewing massive pull requests used to be the biggest bottleneck in our development cycle. Greptile completely changes this by indexing our entire codebase into a comprehensive graph. Unlike basic AI tools that only look at the immediate diff, Greptile evaluates how changes impact cross-file dependencies, shared logic, and related modules. For example, it successfully catches API default mismatches between frontend and backend architectures before the code ever reaches a staging environment. The T-REX (Test, Run, EXecute) feature is incredibly powerful, as it actually writes and executes tests in an isolated sandbox to validate PRs dynamically. Furthermore, if it flags an issue, the native integration lets us send the context directly to local IDE agents like Cursor or Claude Code to instantly apply the fix.

What do you dislike about the product?

Because the core system relies on LLMs, it suffers from inherent stochasticity; a single pass might occasionally miss highly specific edge cases that a rigid, deterministic static analyzer would easily catch. Additionally, out of the box, the AI can sometimes be overly noisy on massive PRs. It requires active team participation—specifically using the thumbs-up or thumbs-down reactions on its comments—for the reinforcement learning engine to adapt to our specific coding standards. Until the system learns those preferences or until you properly configure the .greptile.json file, developers might spend time dismissing false positives.

What problems is the product solving and how is that benefiting you?

It acts as a continuous, automated validation layer that catches complex logic errors and security vulnerabilities early in the pipeline. By surfacing structural and cross-layer issues immediately on the pull request, it drastically cuts down on back-and-forth communication. This has tangibly reduced our average PR merge times and freed up senior engineers to focus strictly on architectural decisions and product design, rather than hunting for broken contracts across different files.

What do you like best about the product?

We have been using greptile for a long time and we like multiple things. 1. The comments on PR's are quite detailed and helpful with a button to fix directly with Claude, which gives a very good user experience. 2. Has very good integration with GITHUB. 3. Even on big PR's it gives the comments after analyzing in a very short time.

What do you dislike about the product?

1. Pricing could be better than their competitor. 2. Misses the overall picture of the PR - which could be improved though.

What problems is the product solving and how is that benefiting you?

Greptile helps us speed up the development cycle, especially by doing a first-pass review of code changes. It’s useful because once it identifies the basic issues, a senior developer doesn’t have to spend a lot of time carefully checking for those simple problems, and can instead focus on more complex logic.

What do you like best about the product?

I like that Greptile makes code reviews easier and helps catch issues that I might miss. It is easy to use and saves time when reviewing code.

What do you dislike about the product?

Sometimes the suggestions are not fully accurate, so I still like to check them myself. Other than that, I don't have any major complaints.

What problems is the product solving and how is that benefiting you?

It helps me save time during code reviews by finding issues that I might miss myself. It also makes it easier to review changes and catch problems early.