Graphite
Graphite is a comprehensive AI-powered code review platform that combines intelligent automation, developer tools, and workflow optimization to transform how engineering teams collaborate on code. The platform’s AI engine, Diamond, provides codebase-aware code review while maintaining human oversight at the center of the development process.
Recently acquired by Cursor in December 2025, Graphite represents a major evolution in AI-augmented development tools, bringing AI code review capabilities into integrated development environments.
What It Is
A full-stack development platform that combines:
- Diamond - Advanced AI code reviewer with sub-3% false positive rate
- Stacked Pull Requests - Break large changes into sequential, reviewable chunks
- Developer Tools - VS Code extension, CLI, PR inbox, merge queue
- Workflow Automation - Customizable review and merge processes
Rather than replacing human reviewers, Graphite acts as an intelligent augmentation layer that handles mechanical checks and identifies common issues, allowing human reviewers to focus on architecture, design decisions, and business logic.
Diamond: The AI Code Reviewer
Core Capabilities
Diamond identifies multiple categories of issues in pull requests:
- Logic Errors: Bugs, edge cases, and incorrect implementations
- Security Vulnerabilities: Potential security risks and unsafe patterns
- Performance Issues: Inefficient code patterns and optimization opportunities
- Code Style Mismatches: Formatting, naming, and style inconsistencies
- Documentation Gaps: Missing or incomplete documentation
- Accidental Commits: Unintended code or debug statements
- Architectural Concerns: Design patterns and maintainability issues
Codebase-Aware Intelligence
Unlike generic linters or basic AI tools, Diamond analyzes code within the complete context of your repository[1]. The tool:
- Reads and understands your entire codebase structure
- Identifies patterns specific to your team’s conventions
- Detects architectural violations or design pattern mismatches
- Catches subtle bugs that depend on codebase context
- Understands your team’s established patterns and enforces consistency
Users report Diamond catching multi-month-old bugs missed by human reviewers and identifying issues before CI tools or manual reviews could spot them[1]. This deep codebase awareness distinguishes Diamond from tools that analyze only the changed code in isolation.
Quality Metrics and False Positive Rate
Diamond maintains a sub-3% false positive rate, meaning the vast majority of its suggestions represent genuine issues worth addressing[2]. This low false positive rate contrasts sharply with generic AI code reviewers that generate high-noise feedback requiring extensive filtering.
The tool provides suggested fixes that developers can apply with a single click, dramatically reducing the friction between identifying problems and implementing solutions[1]. Most Diamond comments include actionable suggestions developers can immediately incorporate.
Evaluation and Quality Assurance Framework
Graphite built Diamond using a sophisticated systematic evaluation approach centered on authentic developer behavior rather than synthetic metrics[1].
Three Primary Success Metrics:
-
Acceptance Rate: Tracks comments that result in developers committing suggested changes. This directly indicates whether feedback is accurate and valuable[1].
-
Upvote Rate: Captures broader developer satisfaction by measuring comments developers explicitly mark as helpful, even if not immediately implemented[1].
-
Downvote Rate: Identifies problematic feedback by tracking comments developers mark as irrelevant or incorrect, guiding improvement efforts[1].
Scoring Functions for Reliability:
The Line Range Validation Scorer ensures Diamond places comments at correct code locations, preventing irrelevant feedback on unrelated sections[1].
The Semantic Similarity Scorer maintains consistency across Diamond’s feedback using automated evaluation tools. When CI infrastructure changes, this scorer verifies that new LLM implementations produce semantically similar comments to previous versions[1].
Continuous Improvement Cycle:
Rather than relying on synthetic metrics, Graphite constructs evaluation frameworks around authentic developer interactions[1]:
- Developers accepting or rejecting suggestions become training data
- Explicit feedback (upvotes/downvotes) guides model improvements
- Separate datasets for different comment types enable multi-dimensional analysis
- Evaluation runs against curated datasets from real pull request usage
Quantified Performance:
For Diamond’s custom rule detection feature (where teams define specific coding standards), the team achieved a 5% reduction in negative rules generated while maintaining comprehensive issue detection[1]. With over 500,000 pull requests reviewed, Diamond maintains consistently low false positive rates across diverse codebases[1].
Core Platform Components
Stacked Pull Requests
Breaks large code changes into smaller, sequential pull requests that are easier to review and merge:
How It Works:
- Automatically splits large feature branches into logical, sequential commits
- Creates PR chains where each PR depends on the previous one
- Automatically rebases PRs to keep them up-to-date with teammates’ changes
- Allows reviewing each logical unit independently
- Enables sequential merging after individual approvals
Benefits:
- Reduces review friction by breaking changes into digestible pieces
- Faster individual PR review cycles
- Easier to identify which PR introduced a specific issue
- Better maintainability of the commit history
- Parallel team development without blocking
Technical Details:
Large feature branch (500 lines of changes)
↓
Automatically split into logical units:
- PR #1: Core functionality (100 lines)
- PR #2: API layer (150 lines)
- PR #3: UI integration (150 lines)
- PR #4: Tests (100 lines)
↓
Each PR reviewed independently with Diamond's feedback
↓
Automatic rebasing handles dependencies
↓
Sequential merge: each PR merges after approval
Developer Tools
VS Code Extension
- Brings code review directly into the editor
- View Diamond’s suggestions without leaving VS Code
- Implements suggested fixes with keyboard shortcuts
- View PR status and reviews in the editor interface
- Minimizes context switching during development
Command-Line Interface
- Full control over stacked PR operations
- Create, rebase, and manage stacked PRs from terminal
- Integrate with Git workflows and scripts
- Automate common review and merge operations
- Scriptable for CI/CD pipelines
PR Inbox
A centralized hub for managing code reviews across repositories:
- View all pending reviews in one place
- Prioritize reviews across multiple repositories
- Track review progress and completion
- Filter by repository, urgency, or reviewer
- Reduce scattered notifications and context switching
Merge Queue
Automated merging with safety guarantees:
- Queues approved PRs for automatic merging
- Handles merge conflicts automatically
- Ensures code passes CI before merging
- Batches changes to reduce CI load
- Prevents manual merge mistakes
Workflow Automation
Custom automation for team review and merge processes:
- Define review requirements (number of approvers, specific reviewers)
- Create conditional workflows (different rules for different paths)
- Automate merges based on custom conditions
- Define team standards in plain language
- Auto-apply standards to every pull request
GitHub Integration
Integration Process
Authorization:
Developers authorize Diamond to access their repositories through GitHub’s OAuth flow[1].
Automatic Analysis:
Once authorized, Diamond analyzes each pull request within seconds and automatically posts feedback as GitHub comments[1].
GitHub Comments Integration:
Diamond’s suggestions appear as standard GitHub comments, allowing normal discussion and collaboration workflows[1].
Always-On Operation:
The tool operates continuously on all pull requests without requiring manual triggering or configuration per PR[1].
Technical Implementation
Comment Structure:
[Diamond Review] Bug detected: Missing null check
At line 42, the variable `user` could be null in this context.
Looking at the `fetchUser()` function, it can return null when
the user is not found. This code doesn't handle that case.
Suggested fix:
- Add null check before accessing user properties
- Handle the null case appropriately Codebase Integration:
- Diamond reads your repository’s structure during analysis
- Understands file relationships and module dependencies
- Analyzes PR changes within the context of the entire codebase
- Compares against established patterns and conventions in your code
Real-Time Feedback:
Comments post as developers push changes, enabling immediate iteration without waiting for human review[1].
Standalone Operation:
Diamond functions independently without requiring Graphite’s broader platform, allowing teams to use just the AI code reviewer if preferred[1].
GitHub-Specific Notes
All current integration documentation focuses on GitHub repositories[1][2][3]. GitLab support is not explicitly mentioned in available resources[1][2][3][4]. For GitLab integration, check current Graphite documentation or contact their team directly.
Practical Workflow Integration
Developer Perspective
Standard Code Review Flow with Diamond:
1. Developer creates pull request on GitHub
↓
2. Diamond analyzes within seconds
↓
3. Diamond posts actionable suggestions as GitHub comments
↓
4. Developer reviews Diamond's feedback
↓
5. Developer accepts suggestions (one-click apply) or modifies as needed
↓
6. PR arrives at human reviewer with foundational issues addressed
↓
7. Human reviewer focuses on architecture, design, business logic
↓
8. After human approval, PR merges automatically
With Stacked PRs:
Large feature development
↓
Graphite automatically splits into sequential PRs:
- Stacked PR 1 (base)
- Stacked PR 2 (depends on 1)
- Stacked PR 3 (depends on 2)
↓
Each PR independently:
- Diamond reviews immediately
- Human reviewer focuses on unit changes
- Faster review cycle per change
↓
Sequential merge maintains commit history integrity
Review Team Perspective
Benefits of Diamond Integration:
- First-pass filtering: Diamond catches ~95% of routine issues (style, formatting, obvious bugs), reducing review workload
- Consistent feedback: Standards applied automatically to every PR without manual oversight
- Higher-level focus: Human reviewers can concentrate on architecture, design decisions, and business logic
- Faster reviews: Cleaner PRs with foundational issues resolved means quicker human approval
- Scalability: Same team reviews more PRs without additional headcount by offloading routine checks
Adoption and Usage
Pricing Structure
Free Tier:
- Up to 100 pull requests per month[2]
- Full Diamond AI code review features
- GitHub integration included
- No credit card required to start[2]
Paid Plans:
- Unlimited pull request reviews
- Additional team features (stacked PRs, merge queues)
- Organization-level automation
- Priority support
- Pricing scales with usage and team size
Companies Using Graphite
Production deployments by engineering leaders:
- Shopify: E-commerce platform using Graphite for development velocity
- Snowflake: Data warehousing platform using Graphite for code quality
- Figma: Design collaboration platform using Graphite for team workflows
These organizations rely on Graphite to help teams review changes efficiently and determine when code is ready for production.
Use Cases and Scenarios
Startup Development Teams
- Limited engineering resources benefit from instant AI review capacity
- Diamond provides second-pass review when adding new engineers is expensive
- Maintains code quality without hiring additional reviewers
Large Organizations with Multiple Repositories
- Enforce consistent standards across dozens of repositories
- Different teams maintain different conventions; Diamond adapts to each
- Centralized review management across distributed teams
Fast-Moving Development Teams
- Review bottlenecks limit deployment velocity
- Diamond’s instant feedback prevents review delays
- Stacked PRs enable parallel development without blocking
Distributed and Remote Teams
- Real-time feedback regardless of timezone
- Reduces back-and-forth communication cycles
- Enables asynchronous, efficient code review
Open Source Projects
- Maintainers receive automatic filtering of common issues before manual review
- Reduces burden of code review on volunteer maintainers
- Provides consistent feedback to contributors
Projects Maintaining Strict Code Quality Standards
- Automatically enforces team conventions without constant oversight
- Custom standards enforcement in plain language
- Prevents quality regressions across releases
Philosophy and Design Approach
Graphite explicitly emphasizes that AI should augment, not replace, human review[2]:
AI Responsibilities:
- Detect obvious bugs and edge cases
- Enforce style and formatting conventions
- Identify security vulnerabilities
- Flag performance issues
- Check for documentation compliance
- Catch accidental commits
Human Reviewer Responsibilities:
- Evaluate architectural decisions
- Assess design patterns and maintainability
- Review business logic and requirements alignment
- Make judgment calls on tradeoffs
- Mentor and grow team members
- Approve changes for production
By dividing responsibilities, Graphite enables both aspects to operate at their best. AI excels at consistent mechanical checks while humans focus on judgment and architecture.
Key Differentiators
vs. Traditional Code Review
- Speed: Diamond provides instant feedback vs. waiting for human reviewers
- Consistency: Every PR receives same standards application vs. subjective review
- Scale: AI handles routine checks; humans focus on substance
- Fatigue: Less repetitive manual checking reduces reviewer fatigue
vs. Generic Linters (ESLint, Pylint, etc.)
- Codebase awareness: Diamond understands your specific codebase vs. generic rules
- Context: Detects issues that depend on business logic and architecture
- False positive rate: <3% vs. high noise from generic rules
- Actionable feedback: Suggestions linked to specific business logic issues
vs. Other AI Code Reviewers
- False positive rate: <3% vs. 5-10%+ for competitors
- Evaluation framework: Real developer feedback vs. synthetic metrics
- Acceptance rate: High rate indicates developers find comments valuable
- No chat interface burden: Focused on code review, not generic chat
vs. Manual Standards Enforcement
- Consistency: Applied uniformly vs. manual inconsistency
- Scalability: Handles unlimited PRs vs. reviewer fatigue
- Cost: Reduces reviewer time vs. time-consuming manual checks
- Reliability: Never forgets standards vs. human oversight gaps
Technical Specifications
Support:
- Primary Integration: GitHub repositories
- Editor Integration: VS Code extension
- Command Line: Full CLI interface
- Platforms: Any OS supporting the CLI/web interface
Performance:
- Analysis time: Seconds per pull request
- False positive rate: <3%
- Upvote rate: High (specific percentage proprietary)
- Acceptance rate: High (specific percentage proprietary)
Scalability:
- Analyzed 500,000+ pull requests[1]
- Maintains consistent quality across diverse codebases
- Handles repositories of any size
Getting Started
1. Connect Repository:
Visit graphite.dev and authorize GitHub access[2].
2. Enable Diamond:
Activate Diamond for your repository; it begins reviewing new PRs immediately[2].
3. Optional: Install VS Code Extension:
Add the Graphite extension for in-editor review feedback[2].
4. Optional: Explore Stacked PRs:
Enable stacked PR support for larger teams and complex features[2].
5. Custom Automation:
Define team-specific review workflows and merge automation rules[2].
Practical Considerations
Best For:
- Teams valuing both speed and code quality
- Organizations managing multiple repositories
- Distributed and remote teams
- Fast-moving startups and scaling companies
- Projects with strict quality standards
Learning Curve:
Minimal. Integrates into existing GitHub workflows without process change.
Implementation Time:
Connect GitHub account → Diamond starts reviewing within minutes.
Cost-Benefit:
Free tier enables experimentation. Paid plans scale with usage; ROI comes from reduced review time and maintained code quality.
Integration:
Works alongside existing linters, CI/CD, and testing tools. Complements rather than replaces them.
References
- Official Graphite website: https://graphite.dev
- Recently acquired by Cursor (December 2025)
- AI-augmented code review platform serving Shopify, Snowflake, Figma
- Diamond AI reviewer with sub-3% false positive rate
- Free tier: 100 PRs/month; paid plans available