Greptile

What do you like best about the product?

As an AI engineer managing a complex claims processing platform, reviewing pull requests across our backend monorepo is a massive time sink. I appreciate how Greptile acts as a true codebase-aware agent rather than just a standard auto-complete tool. Because it's integrated directly into our GitHub Actions workflow, it indexes the entire repository and provides highly contextual review comments whenever a PR is opened. I really value its cross-file understanding. For example, if a junior engineer modifies a core FastAPI Pydantic schema, Greptile successfully flags that this specific variable change will break our downstream LangChain JSON output parsers. Having an automated reviewer that actually understands the structural relationship between our API routing layer and our core machine learning extraction logic is invaluable.

What do you dislike about the product?

The initial repository indexing phase is a bit slow, especially as our codebase has grown to include massive infrastructure-as-code files and heavy data pipelines. Additionally, while Greptile is remarkably accurate with standard Python and FastAPI patterns, it occasionally hallucinates when suggesting hyper-specific PyTorch tensor shapes or referencing deprecated LangChain methods in PR comments. Because of this, senior engineering validation is still mandatory for complex machine learning diffs—it accelerates triage, but human oversight remains essential. On the enterprise side, deployment options and strict data governance controls could be streamlined, particularly for teams in heavily regulated sectors like insurance handling sensitive backend logic.

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

Greptile drastically reduces the manual code review burden on our senior engineering team by catching cross-file dependency breaks before they ever reach staging. In our claims platform, we run tight integrations between our FastAPI endpoints, LangChain agent chains, and PyTorch extraction workers. Previously, a subtle change to a shared schema or response model could silently break downstream vector embedding routines or JSON output parsers without being caught during manual peer review. Greptile flags these ripple effects directly on the pull request diff, saving hours of manual tracing and preventing staging regressions.

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.