Key differentiators:
1. One-click installation through GitHub Marketplace - no configuration needed 2. Analyzes your entire codebase first to understand: - Project structure - Coding patterns - Naming conventions - Architecture decisions 3. Completely free with no usage limits 4. Fully automated PR reviews with zero human intervention required
Technical implementation: - Built on top of llama-github (my open source project) - Focuses on deep code understanding rather than superficial linting - Provides context-aware suggestions with explanations
The goal is to handle routine reviews automatically so developers can focus on complex architectural decisions. Currently in production and processing real PRs.
Try it for free: https://github.com/marketplace/llamapreview/
Looking for feedback from the HN community, especially on: - What features would make this more useful for your workflow? - How do you currently handle code review automation? - What aspects of code understanding matter most to you?
I hate to be the compliance guy, but even from a startup perspective you'd at least want to mention what you promise to do here.
The underlying library it depends on is open source, but this app isn't. Presumably it's holding the codebase in state.
No website to speak of, just boilerplate text to satisfy Github's marketplace submission process.
It does not really matter for FOSS projects. For those fearing licence laundering, don’t worry it will be done anyway for any public code.
1. Code Processing: All code analysis happens in-memory during the PR review process. We don't permanently store any of your source code.
2. Data Retention: We only store the PR comments we generate, not the underlying code. This helps maintain a history of our suggestions while protecting your IP.
3. Privacy Focus: We take data privacy seriously and have successfully worked with both open-source and closed-source projects. We're always open to suggestions on how to further enhance our privacy measures.
If you have specific privacy requirements or suggestions, I'd be happy to discuss them.
1. Description* reeks of AI slop; it extended a surface-level prompt into longer surface-level insights. *: description as in GitHub README
2. #1 creates a situation where I go through reading this long thing, and realize it has no answers to even the first-level questions that would be on anyones mind (what model? where is it run?). For this to become something I'll take the time to integrate into my core workflow and try, it has to be *much* more transparent.
3. Claims in the description are ~impossible.
3b. Up front, I feel your pain, there's a hard set of constraints to navigate here given A) marketing needs to be concise B) people play fast and loose with conciseness vs. accuracy C) you need to sounds as good as the people in B.
3c. That being said, we're crossing into year 3 of post-ChatGPT. People, especially in your target audience, will know when they're reading* that you're reframing "I give text to the LLM which can theoratically do $X" into features, and users expect features to be designed* and intentional. If they are, you should definitely highlight that to differentiate from people who just throw it into the LLM.
3d. Analyzes your entire repository context: impossible, literally, unless you're feeding it to Gemini only. I have about 20KLOC and its multiples of Llama context size.
3e. "Understands code relationships and dependencies" see 3c.
3f. "Contextual Analysis: Reviews code changes within the full repository context": see 3d.
3g. "Language Agnostic: Supports all major programming languages.": see 3c (is there actual work done to do this, or is this just "well, given I just send the text to the LLM, everything is supported"?)
4. nit: Should be "Show HN: LlamaPReview, AI Github PR Reviewer That Learns Your Codebase"
You're absolutely right about the marketing copy - we should be more precise and transparent about what we actually do vs. what's aspirational.
Regarding "understanding code relationships and dependencies": We're building a knowledge graph of the entire repository that captures code relationships, function calls, and module dependencies. This graph is then used with GraphRAG to fetch relevant context for each PR, allowing the LLM to understand the broader impact of changes.
Important to note: We take privacy very seriously. All code analysis happens in-memory during PR reviews - we don't permanently store any source code or build persistent knowledge bases from customer code. The knowledge graph is generated and used on-the-fly for each review session.
This approach helps us work around context window limitations while providing meaningful insights. However, I should note that this feature is still under active development - we're continuously improving the graph construction and relevancy matching.
Would love to hear your thoughts on this approach. We're committed to building something genuinely useful for developers rather than just another LLM wrapper.
That might be sort of doable, by extracting all function signatures together with brief descriptions, and including that in the context, and maybe a graph showing how they call each other,
but none of the actual implementations. Except for the file(s) under review, which would be included in full.
- Project structure and architecture - Coding patterns and conventions - Dependencies and relationships between components
This allows us to provide more relevant and context-aware reviews while maintaining data privacy (some advanced features still is under developing)
As long as you have good pipelines, linters, a careful suite of tests at different levels like unit, integration, e2e and if you can test things in an acceptable like environment then human code reviews offer very very little benefit…
Is the AI tool going to ask why something was implemented in a way that might not match the requirement specs? Is it even going to know what the requirements are for the code or is it going to rubber stamp a review because the code looks reasonable?
If you think human code reviews offer very very little benefit then you probably aren't doing them right.
1. It helps save senior developers' time by handling routine checks and providing initial insights 2. It analyzes the entire codebase context to provide more meaningful reviews 3. It's particularly useful for identifying patterns and relationships across the codebase
The goal is to make human reviewers more efficient, allowing them to focus on complex architectural decisions and critical business logic. We've seen positive results from both open-source and commercial projects using this approach.
might make sense for open source. closed source is no go for this.
I've found the code walkthroughs very useful
> Unlimited AI-powered PR reviews
FAQ says:
> A: Yes, we currently offer a free tier with usage limits. You can install and use LlamaPReview without binding any payment method.
Only "free tier" is available.