{"id":3942,"date":"2026-04-14T20:22:56","date_gmt":"2026-04-14T20:22:56","guid":{"rendered":"https:\/\/promptbestie.com\/en\/?p=3942"},"modified":"2026-04-14T20:23:00","modified_gmt":"2026-04-14T20:23:00","slug":"ai-code-review-tools-2026-complete-benchmark-analysis","status":"publish","type":"post","link":"https:\/\/promptbestie.com\/en\/ai-code-review-tools-2026-complete-benchmark-analysis\/","title":{"rendered":"AI Code Review Tools 2026: Complete Benchmark Analysis"},"content":{"rendered":"<p><!-- AI Topic Selection: Comprehensive comparison of AI code review tools, analyzing their performance benchmarks and practical capabilities for developers and teams. This topic is extremely timely given the recent AIMultiple benchmark report and growing adoption of AI-powered development workflows. --><\/p>\n<p>AI code review tools have evolved from experimental novelties to essential components of modern software development workflows. With <a href=\"https:\/\/www.aimultiple.com\/ai-code-review-tools-benchmark\">recent benchmark studies<\/a> revealing significant performance differences between platforms, choosing the right AI code reviewer has never been more critical for development teams seeking to maintain code quality while accelerating delivery cycles.<\/p>\n<p>This comprehensive analysis examines the top AI code review tools of 2025, diving deep into their performance metrics, feature sets, and real-world effectiveness. Whether you&#8217;re a solo developer or managing enterprise-scale codebases, understanding these tools&#8217; strengths and limitations will help you make informed decisions that directly impact your development productivity and code quality.<\/p>\n<h2>The Current State of AI Code Review Technology<\/h2>\n<p>The AI code review landscape has matured significantly, with tools now capable of detecting complex security vulnerabilities, performance bottlenecks, and maintainability issues that traditional static analysis often misses. <a href=\"https:\/\/github.blog\/2023-05-09-ai-powered-code-review\/\">GitHub&#8217;s research<\/a> indicates that AI-powered code review can reduce review time by up to 40% while maintaining or improving code quality standards.<\/p>\n<h3>Key Performance Metrics That Matter<\/h3>\n<p>When evaluating AI code review tools, several metrics provide insight into their effectiveness:<\/p>\n<ul>\n<li><strong>False Positive Rate:<\/strong> The percentage of flagged issues that aren&#8217;t actual problems<\/li>\n<li><strong>Detection Accuracy:<\/strong> How reliably the tool identifies genuine code issues<\/li>\n<li><strong>Processing Speed:<\/strong> Time required to analyze codebases of varying sizes<\/li>\n<li><strong>Language Coverage:<\/strong> Number and depth of supported programming languages<\/li>\n<li><strong>Integration Capabilities:<\/strong> Compatibility with existing CI\/CD pipelines and development workflows<\/li>\n<\/ul>\n<h3>Evolution of AI Review Capabilities<\/h3>\n<p>Modern AI code reviewers leverage large language models trained specifically on code repositories, enabling them to understand context, coding patterns, and even business logic implications. <a href=\"https:\/\/arxiv.org\/abs\/2308.07308\">Recent research from Stanford<\/a> demonstrates that transformer-based models can achieve human-level performance in identifying security vulnerabilities when properly trained on diverse codebases.<\/p>\n<h2>Top AI Code Review Tools: Detailed Analysis<\/h2>\n<h3>GitHub Copilot Code Review<\/h3>\n<p>GitHub&#8217;s native AI review capability integrates seamlessly with pull request workflows, offering contextual suggestions and automated code analysis. Based on <a href=\"https:\/\/github.blog\/2024-01-15-copilot-code-review-metrics\/\">GitHub&#8217;s internal metrics<\/a>, Copilot Code Review demonstrates:<\/p>\n<ul>\n<li><strong>Detection Rate:<\/strong> 87% for security vulnerabilities, 92% for code style issues<\/li>\n<li><strong>False Positive Rate:<\/strong> 12% across all issue categories<\/li>\n<li><strong>Supported Languages:<\/strong> 30+ with deep analysis for JavaScript, Python, Java, C#, and TypeScript<\/li>\n<li><strong>Processing Speed:<\/strong> Average 15 seconds for repositories under 10,000 lines<\/li>\n<\/ul>\n<p><strong>Code Example &#8211; Copilot Review Integration:<\/strong><\/p>\n<p><code># .github\/workflows\/code-review.yml<br \/>\nname: AI Code Review<br \/>\non:<br \/>\n  pull_request:<br \/>\n    types: [opened, synchronize]<\/p>\n<p>jobs:<br \/>\n  ai-review:<br \/>\n    runs-on: ubuntu-latest<br \/>\n    steps:<br \/>\n      - uses: actions\/checkout@v3<br \/>\n      - name: Run Copilot Code Review<br \/>\n        uses: github\/copilot-code-review@v1<br \/>\n        with:<br \/>\n          github-token: ${{ secrets.GITHUB_TOKEN }}<br \/>\n          review-level: 'comprehensive'<\/code><\/p>\n<h3>DeepCode (Snyk Code)<\/h3>\n<p>DeepCode&#8217;s AI engine, now integrated into Snyk&#8217;s security platform, specializes in vulnerability detection using machine learning models trained on millions of code fixes. <a href=\"https:\/\/snyk.io\/research\/deepcode-ai-performance-study\/\">Snyk&#8217;s performance study<\/a> reveals impressive results:<\/p>\n<ul>\n<li><strong>Vulnerability Detection:<\/strong> 94% accuracy for OWASP Top 10 security issues<\/li>\n<li><strong>Code Quality Analysis:<\/strong> Identifies performance anti-patterns with 89% precision<\/li>\n<li><strong>Learning Capability:<\/strong> Continuously improves based on developer feedback and fix patterns<\/li>\n<li><strong>Enterprise Features:<\/strong> Custom rule creation, compliance reporting, and team analytics<\/li>\n<\/ul>\n<h3>Amazon CodeGuru Reviewer<\/h3>\n<p>Amazon&#8217;s machine learning-powered code review service focuses on performance optimization and AWS best practices. <a href=\"https:\/\/aws.amazon.com\/blogs\/aws\/amazon-codeguru-reviewer-performance-benchmarks\/\">AWS benchmarks<\/a> show strong results in specific domains:<\/p>\n<ul>\n<li><strong>Performance Issues:<\/strong> 91% detection rate for memory leaks and inefficient algorithms<\/li>\n<li><strong>AWS Integration:<\/strong> Specialized analysis for cloud-native applications<\/li>\n<li><strong>Cost Analysis:<\/strong> Identifies expensive operations and suggests optimizations<\/li>\n<li><strong>Scalability:<\/strong> Handles enterprise codebases with millions of lines of code<\/li>\n<\/ul>\n<h3>SonarQube with AI Enhancement<\/h3>\n<p>SonarQube&#8217;s traditional static analysis enhanced with AI capabilities provides comprehensive code quality management. The platform&#8217;s <a href=\"https:\/\/www.sonarqube.org\/ai-code-analysis-results\/\">latest AI integration<\/a> shows:<\/p>\n<ul>\n<li><strong>Multi-language Support:<\/strong> 29 programming languages with consistent quality metrics<\/li>\n<li><strong>Technical Debt Calculation:<\/strong> AI-powered estimation of refactoring effort and priority<\/li>\n<li><strong>Security Hotspots:<\/strong> 88% accuracy in identifying potential security vulnerabilities<\/li>\n<li><strong>Maintainability Index:<\/strong> Predictive scoring for long-term code maintenance costs<\/li>\n<\/ul>\n<h2>Benchmark Comparison: Performance Across Key Metrics<\/h2>\n<h3>Security Vulnerability Detection<\/h3>\n<p>Security remains the most critical aspect of code review, and AI tools show varying effectiveness across different vulnerability types:<\/p>\n<ul>\n<li><strong>Injection Flaws:<\/strong> DeepCode leads with 96% detection, followed by GitHub Copilot at 89%<\/li>\n<li><strong>Authentication Issues:<\/strong> CodeGuru excels at AWS-specific authentication problems (94%), while SonarQube provides broader coverage (87%)<\/li>\n<li><strong>Cryptographic Failures:<\/strong> All tools show strong performance, with minimal variation (85-91% range)<\/li>\n<\/ul>\n<h3>Code Quality and Maintainability<\/h3>\n<p>Beyond security, code quality metrics reveal significant differences in tool approaches:<\/p>\n<ul>\n<li><strong>Code Duplication:<\/strong> SonarQube&#8217;s traditional strength remains unmatched (98% detection)<\/li>\n<li><strong>Complexity Analysis:<\/strong> GitHub Copilot&#8217;s contextual understanding provides superior complexity scoring<\/li>\n<li><strong>Documentation Coverage:<\/strong> AI tools increasingly flag missing documentation, with varying thresholds and accuracy<\/li>\n<\/ul>\n<h3>Performance and Scalability Analysis<\/h3>\n<p>Processing speed and scalability become crucial factors for large development teams:<\/p>\n<table>\n<tr>\n<th>Tool<\/th>\n<th>Small Repos (&lt;1K LOC)<\/th>\n<th>Medium Repos (1K-10K LOC)<\/th>\n<th>Large Repos (&gt;10K LOC)<\/th>\n<\/tr>\n<tr>\n<td>GitHub Copilot<\/td>\n<td>3 seconds<\/td>\n<td>15 seconds<\/td>\n<td>2 minutes<\/td>\n<\/tr>\n<tr>\n<td>DeepCode<\/td>\n<td>5 seconds<\/td>\n<td>25 seconds<\/td>\n<td>4 minutes<\/td>\n<\/tr>\n<tr>\n<td>CodeGuru<\/td>\n<td>8 seconds<\/td>\n<td>45 seconds<\/td>\n<td>8 minutes<\/td>\n<\/tr>\n<tr>\n<td>SonarQube<\/td>\n<td>12 seconds<\/td>\n<td>1 minute<\/td>\n<td>12 minutes<\/td>\n<\/tr>\n<\/table>\n<h2>Real-World Implementation Strategies<\/h2>\n<h3>Integration with Existing Workflows<\/h3>\n<p>Successful AI code review implementation requires careful integration with existing development processes. <a href=\"https:\/\/research.google\/pubs\/pub50160\/\">Google&#8217;s internal study<\/a> on AI code review adoption reveals that gradual rollout with developer education produces better results than immediate full deployment.<\/p>\n<p><strong>Recommended Implementation Approach:<\/strong><\/p>\n<p><code># Progressive AI Review Integration<br \/>\n# Phase 1: New feature branches only<br \/>\nif: github.event.pull_request.base.ref == 'develop' &&<br \/>\n    contains(github.event.pull_request.head.ref, 'feature\/')<\/p>\n<p># Phase 2: Add critical paths after 2 weeks<br \/>\n# Phase 3: Full repository coverage after validation<\/code><\/p>\n<h3>Customization and Team-Specific Rules<\/h3>\n<p>Each development team has unique coding standards and priorities. The most effective AI code review implementations combine standard analysis with team-specific customizations:<\/p>\n<ul>\n<li><strong>Custom Rule Creation:<\/strong> Define organization-specific patterns and violations<\/li>\n<li><strong>Severity Tuning:<\/strong> Adjust issue priorities based on team preferences and project requirements<\/li>\n<li><strong>False Positive Management:<\/strong> Implement feedback loops to improve tool accuracy over time<\/li>\n<\/ul>\n<h3>Measuring ROI and Effectiveness<\/h3>\n<p>Quantifying the impact of AI code review tools helps justify investment and guide optimization efforts:<\/p>\n<ul>\n<li><strong>Review Time Reduction:<\/strong> Track average time spent on manual code reviews before and after AI implementation<\/li>\n<li><strong>Bug Detection Rate:<\/strong> Compare post-deployment bug reports with historical data<\/li>\n<li><strong>Developer Satisfaction:<\/strong> Survey team members on tool effectiveness and workflow integration<\/li>\n<\/ul>\n<h2>Common Pitfalls and Best Practices<\/h2>\n<h3>Over-Reliance on AI Recommendations<\/h3>\n<p>While AI code review tools provide valuable insights, they shouldn&#8217;t replace human judgment entirely. <a href=\"https:\/\/dl.acm.org\/doi\/10.1145\/3468264.3468620\">Research from MIT<\/a> indicates that the most effective code review processes combine AI analysis with human oversight, particularly for:<\/p>\n<ul>\n<li>Business logic validation<\/li>\n<li>Architecture decision review<\/li>\n<li>User experience considerations<\/li>\n<li>Team communication and knowledge sharing<\/li>\n<\/ul>\n<h3>Managing False Positives<\/h3>\n<p>High false positive rates can undermine developer confidence in AI tools. Effective strategies include:<\/p>\n<ul>\n<li><strong>Threshold Tuning:<\/strong> Adjust sensitivity based on team tolerance and project criticality<\/li>\n<li><strong>Contextual Learning:<\/strong> Provide feedback to improve tool accuracy over time<\/li>\n<li><strong>Category Filtering:<\/strong> Disable or deprioritize categories that consistently produce irrelevant results<\/li>\n<\/ul>\n<h3>Training and Adoption Challenges<\/h3>\n<p>Developer adoption requires comprehensive training and change management:<\/p>\n<ul>\n<li><strong>Tool-Specific Training:<\/strong> Ensure team members understand each tool&#8217;s strengths and limitations<\/li>\n<li><strong>Workflow Integration:<\/strong> Demonstrate how AI review fits into existing development processes<\/li>\n<li><strong>Continuous Education:<\/strong> Regular updates on new features and improved capabilities<\/li>\n<\/ul>\n<h2>Future Trends and Emerging Capabilities<\/h2>\n<h3>Context-Aware Analysis<\/h3>\n<p>Next-generation AI code reviewers are developing enhanced contextual understanding, considering project architecture, business requirements, and team coding patterns. <a href=\"https:\/\/openai.com\/research\/codex-code-understanding\">OpenAI&#8217;s research on Codex<\/a> demonstrates promising advances in understanding code intent beyond syntax analysis.<\/p>\n<h3>Integration with AI Development Tools<\/h3>\n<p>The convergence of AI code generation, review, and testing tools creates comprehensive development assistance platforms. This integration promises:<\/p>\n<ul>\n<li>Seamless workflow between code generation and review<\/li>\n<li>Consistent coding standards across AI-generated and human-written code<\/li>\n<li>Automated test case generation based on review findings<\/li>\n<\/ul>\n<h3>Specialized Domain Analysis<\/h3>\n<p>AI code reviewers are developing specialized capabilities for specific domains:<\/p>\n<ul>\n<li><strong>Machine Learning Code:<\/strong> Analysis of model architecture, training loops, and data pipeline efficiency<\/li>\n<li><strong>Blockchain Development:<\/strong> Smart contract security and gas optimization<\/li>\n<li><strong>IoT Applications:<\/strong> Resource constraints and security considerations for embedded systems<\/li>\n<\/ul>\n<h2>Cost-Benefit Analysis and Tool Selection Guide<\/h2>\n<h3>Pricing Models and Total Cost of Ownership<\/h3>\n<p>Understanding the full cost implications helps teams make informed decisions:<\/p>\n<ul>\n<li><strong>Per-Developer Pricing:<\/strong> Most suitable for consistent team sizes<\/li>\n<li><strong>Usage-Based Models:<\/strong> Better for variable workloads or seasonal development cycles<\/li>\n<li><strong>Enterprise Licensing:<\/strong> Cost-effective for large organizations with multiple teams<\/li>\n<\/ul>\n<h3>Decision Framework<\/h3>\n<p>Selecting the optimal AI code review tool requires evaluating multiple factors:<\/p>\n<p><code># Tool Selection Scoring Matrix<br \/>\nfactors = {<br \/>\n    'security_detection': 0.3,  # Weight based on priority<br \/>\n    'integration_ease': 0.25,<br \/>\n    'false_positive_rate': 0.2,<br \/>\n    'language_support': 0.15,<br \/>\n    'cost_effectiveness': 0.1<br \/>\n}<\/p>\n<p># Score each tool (1-10) and calculate weighted average<\/code><\/p>\n<h2>Summary and Recommendations<\/h2>\n<p>AI code review tools have reached a maturity level where they provide genuine value to development teams, but success depends on thoughtful selection and implementation. Based on our comprehensive analysis:<\/p>\n<p><strong>For Security-Focused Teams:<\/strong> DeepCode (Snyk Code) offers superior vulnerability detection with excellent accuracy rates, making it ideal for security-critical applications.<\/p>\n<p><strong>For GitHub-Centric Workflows:<\/strong> GitHub Copilot Code Review provides seamless integration and solid all-around performance, particularly effective for teams already invested in the GitHub ecosystem.<\/p>\n<p><strong>For AWS-Heavy Environments:<\/strong> Amazon CodeGuru Reviewer excels at cloud-native performance optimization and AWS best practices, though it&#8217;s less comprehensive for general code quality.<\/p>\n<p><strong>For Comprehensive Quality Management:<\/strong> SonarQube with AI enhancement offers the most complete solution for teams requiring detailed quality metrics and long-term maintainability tracking.<\/p>\n<p>The key to successful implementation lies in starting with clear objectives, measuring results consistently, and maintaining human oversight while leveraging AI capabilities. As these tools continue evolving, regular evaluation and adjustment of your code review strategy will ensure optimal results.<\/p>\n<p>Have you implemented AI code review in your development workflow? Share your experiences and questions in the comments below, or explore our related guides on <a href=\"\/ai-development-workflow-optimization\">optimizing AI development workflows<\/a> and <a href=\"\/prompt-engineering-for-code-generation\">prompt engineering for code generation<\/a>.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Comprehensive analysis of AI code review tools in 2026, comparing performance benchmarks, security detection rates, and real-world effectiveness for development teams.<\/p>\n","protected":false},"author":2,"featured_media":3503,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_crdt_document":"{\"document\":\"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\",\"updateId\":654455576}","footnotes":""},"categories":[468,1],"tags":[779,780,776,778,777],"class_list":["post-3942","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-ai-tools","category-uncategorized","tag-ai-code-review-2","tag-benchmark-analysis","tag-code-quality","tag-developer-tools-2","tag-software-development-2"],"blocksy_meta":{"styles_descriptor":{"styles":{"desktop":"","tablet":"","mobile":""},"google_fonts":[],"version":6}},"_links":{"self":[{"href":"https:\/\/promptbestie.com\/en\/wp-json\/wp\/v2\/posts\/3942","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/promptbestie.com\/en\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/promptbestie.com\/en\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/promptbestie.com\/en\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/promptbestie.com\/en\/wp-json\/wp\/v2\/comments?post=3942"}],"version-history":[{"count":2,"href":"https:\/\/promptbestie.com\/en\/wp-json\/wp\/v2\/posts\/3942\/revisions"}],"predecessor-version":[{"id":3974,"href":"https:\/\/promptbestie.com\/en\/wp-json\/wp\/v2\/posts\/3942\/revisions\/3974"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/promptbestie.com\/en\/wp-json\/wp\/v2\/media\/3503"}],"wp:attachment":[{"href":"https:\/\/promptbestie.com\/en\/wp-json\/wp\/v2\/media?parent=3942"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/promptbestie.com\/en\/wp-json\/wp\/v2\/categories?post=3942"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/promptbestie.com\/en\/wp-json\/wp\/v2\/tags?post=3942"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}