# ai code review

AI code review uses artificial intelligence to automate the evaluation of source code for quality, standards, bugs, and security issues.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## From Code Review Comments to Reuse in Production: An Industrial Study of Extracted Rules

DevFeed: [From Code Review Comments to Reuse in Production: An Industrial Study of Extracted Rules](<https://devfeed.tech/articles/from-code-review-comments-to-reuse-in-production-an-industrial-study-of-extracted-rules-145783.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.25918>)

Author: Mutsuha Asada, Yuhei Nakasaka, Keito Tabuchi, Shinpei Hayashi

Published: 2026-11-20T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Code review](<https://devfeed.tech/topics/code-review.md>), [ai code review](<https://devfeed.tech/topics/ai-code-review.md>), [rule-engine](<https://devfeed.tech/topics/rule-engine.md>)

Tags: [code-review](<https://devfeed.tech/tags/code-review.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [industrial](<https://devfeed.tech/tags/industrial.md>), [production](<https://devfeed.tech/tags/production.md>), [reuse](<https://devfeed.tech/tags/reuse.md>), [rules](<https://devfeed.tech/tags/rules.md>), [study](<https://devfeed.tech/tags/study.md>)

### AI overview

In a 65-day production study of Kleene, counting how often later review comments cited an extracted rule did not reveal what the rule contributed. Among 56 clauses from 12 rules cited as reasons, 2 were explicit in their source review threads, 38 added conditions, and 16 had no located source passage; many rule-attributed comments requested no change. On 20 constructed changes, a model using extracted rules met detection criteria on all 10 cases requiring a report, versus 8 of 10 using the unedited source threads, though the confidence interval included no difference. Of 464 deployed rules, 55.8% were named, 42.0% produced a non-withheld comment, and 20.3% led to a recorded code change; the largest drop came before a rule was named. Ranking rules in advance also showed no clear advantage over random selection. The authors recommend tracking each stage separately and evaluating rules against their source threads.

### Source excerpt

arXiv:2611.25918v1 Announce Type: new Abstract: Much organization-specific code review knowledge remains embedded in comments on individual changes, and recent systems reuse it by turning those comments into rules a language model applies to later changes. Teams must then decide which rules to keep, and the evidence at hand is how often the system's later comments name each rule. Tracing the rules of one such system, Kleene, through 65 days of production use, we found that such a count does not show what a rule contributed. A rule attribution indicates neither whether the source content was preserved nor whether the comment requested a change. Of 56 clauses in 12 rules that later comments named as their reason, 2 were explicit in a source review thread, 38 added conditions to a corresponding passage, and 16 had no passage we could locate; 45 of 79 further comments naming those rules requested no change, 27 of them while stating that the rule applied. On 20 constructed code changes, a reviewer model given only the unedited source thread met the detection criteria on 8 of the 10 that require a report, against 10 of 10 with the extracted rule, a difference whose confidence interval includes zero. Stage counts locate where rules drop out but not why: of 464 rules deployed while the rule-based reviewer subagent ran in their repository, 259 (55.8%) were named, 195 (42.0%) produced a comment that was not withheld, and 94 (20.3%) one with a recorded code change; the largest reduction occurred before any rule was named. Nor did the deployment-time properties we tested settle the choice in advance: retaining the top-ranked half preserved 53.8% of the rules that later produced a non-withheld comment, against 49.2% at random, a difference whose confidence interval includes zero. Judging extracted rules therefore calls for recording each stage separately and comparing each rule against the threads it was extracted from.

## AI Code Review Requires Revision-Aware Evidence of Concern Resolution

DevFeed: [AI Code Review Requires Revision-Aware Evidence of Concern Resolution](<https://devfeed.tech/articles/ai-code-review-requires-revision-aware-evidence-of-concern-resolution-142147.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.23275>)

Author: Mamdouh Alenezi

Published: 2026-11-19T05:00:00Z

Content type: opinion

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [ai code review](<https://devfeed.tech/topics/ai-code-review.md>), [Code review](<https://devfeed.tech/topics/code-review.md>), [test impact analysis](<https://devfeed.tech/topics/test-impact-analysis.md>), [Test automation](<https://devfeed.tech/topics/test-automation.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [code-review](<https://devfeed.tech/tags/code-review.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [dependencies](<https://devfeed.tech/tags/dependencies.md>), [revision](<https://devfeed.tech/tags/revision.md>), [test](<https://devfeed.tech/tags/test.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

Closing a review thread or changing a commented line is not evidence that a concern is fixed; later revisions may undo a repair. The paper proposes treating concerns as persistent verification obligations, with REVAL rechecking evidence when its dependencies change. In synthetic histories, REVAL matched exhaustive reassessment across 6,420 paired comparisons while reducing post-comment test executions by 34%. Its false-resolution rate and recurrence detection varied with how witnesses were selected: 0.11 and 80.4% with three oracle-sampled witnesses, versus 0.13 and 88.3% using witnesses from review comments and independent held-out checks. A sticky outdated-line proxy falsely called 72.9% of unresolved states resolved, and stopping after initial success missed all recurrences. The controlled results distinguish revalidation correctness from witness adequacy; maintenance overhead made REVAL slower for microsecond-scale tests, with an estimated break-even test cost of 0.42 ms.

### Source excerpt

arXiv:2611.23275v1 Announce Type: new Abstract: AI-assisted code review increasingly judges whether reported concerns have been resolved. Yet closing a thread or modifying a commented line does not establish repair, and later revisions can invalidate earlier fixes. This position paper argues that resolution requires inspectable, revision-specific evidence that is revalidated when its dependencies change. We model review concerns as persistent verification obligations, derive a sufficient condition under which dependency-gated revalidation matches exhaustive reassessment, and introduce REVAL, a lightweight procedure adapting principles from regression-test selection and build systems. We evaluate REVAL against oracle ground truth in synthetic revision histories covering 441 concerns, 1,284 assessments, and 12 defect families. A sticky outdated-line proxy falsely marked 72.9% of unresolved states as resolved, while stopping checks after initial success missed every recurrence. With three oracle-sampled witnesses, REVAL achieved a false-resolution rate of 0.11 (95% CI: 0.06-0.16) and detected 80.4% of recurrences. With witnesses derived solely from review comments and assessed using independent held-out checks, the corresponding results were 0.13 and 88.3%. Across 6,420 paired comparisons, REVAL matched exhaustive reassessment while reducing post-comment test executions by 34%. Maintenance overhead increased runtime for microsecond-scale tests; the estimated break-even test cost was 0.42 ms. These findings support revision-aware evidence maintenance in a controlled setting, while distinguishing revalidation correctness from witness adequacy. A prespecified evaluation protocol outlines how to assess generalisability in real review histories.

## When Single Agent Is Enough: Rethinking Multi-Agent Systems for Automated Code Review

DevFeed: [When Single Agent Is Enough: Rethinking Multi-Agent Systems for Automated Code Review](<https://devfeed.tech/articles/when-single-agent-is-enough-rethinking-multi-agent-systems-for-automated-code-review-142152.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.23283>)

Author: Jiawei Li, Hoa Khanh Dam, Iftekhar Ahmed

Published: 2026-11-19T05:00:00Z

Content type: comparison

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>), [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Multi Agent Systems](<https://devfeed.tech/topics/multi-agent-systems.md>), [Code review](<https://devfeed.tech/topics/code-review.md>), [ai code review](<https://devfeed.tech/topics/ai-code-review.md>)

Tags: [code](<https://devfeed.tech/tags/code.md>), [code-review](<https://devfeed.tech/tags/code-review.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [multi-agent](<https://devfeed.tech/tags/multi-agent.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>)

### AI overview

The study compares single-agent (SA) and multi-agent (MA) designs for review comment generation and code refinement. It reports that SA approaches perform comparably to, and sometimes outperform, MA systems, despite simpler architecture. MA systems add architectural complexity and runtime overhead, so the findings challenge treating them as the default for complex software engineering tasks. The supplied evidence is an abstract and does not provide methods or detailed results.

### Source excerpt

arXiv:2611.23283v1 Announce Type: new Abstract: Code review plays a critical role in identifying software quality issues and ensuring system robustness. Prior work has proposed techniques for Review Comment Generation (RCG) and Code Refinement (CR), with recent Multi-Agent (MA) approaches achieving state-of-the-art results by coordinating agents specialized in different quality dimensions. However, MA systems introduce substantial architectural complexity and runtime overhead, and recent evidence suggests they may underperform Single-Agent (SA) approaches in certain tasks. In this work, we systematically compare MA and SA designs for RCG and CR. Surprisingly, our results show that SA approaches perform comparably to- and sometimes outperform-MA systems, despite their simpler design. These findings challenge the prevailing assumption that MA architectures are the default choice for complex software engineering tasks.

## Aikido's Deep Review finds Java4Shell in the PR that introduced it

DevFeed: [Aikido's Deep Review finds Java4Shell in the PR that introduced it](<https://devfeed.tech/articles/aikido-s-deep-review-finds-java4shell-in-the-pr-that-introduced-it-143872.md>)

Original publisher: [Read original article](<https://www.aikido.dev/blog/deep-review-finds-java4shell-in-pr>)

Author: Debarshi

Published: 2026-11-18T19:04:00Z

Content type: news

Language: en

Sources: [Aikido Security's Blog](<https://devfeed.tech/sources/aikido-security-s-blog.md>)

Topics: [ai code review](<https://devfeed.tech/topics/ai-code-review.md>), [Code review](<https://devfeed.tech/topics/code-review.md>), [openjdk](<https://devfeed.tech/topics/openjdk.md>), [software security audit](<https://devfeed.tech/topics/software-security-audit.md>), [Pull Request](<https://devfeed.tech/topics/pull-request.md>), [cve remediation](<https://devfeed.tech/topics/cve-remediation.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>)

Tags: [17](<https://devfeed.tech/tags/17.md>), [2021](<https://devfeed.tech/tags/2021.md>), [2026](<https://devfeed.tech/tags/2026.md>), [accelerated](<https://devfeed.tech/tags/accelerated.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-code](<https://devfeed.tech/tags/ai-code.md>), [analysis](<https://devfeed.tech/tags/analysis.md>), [arm](<https://devfeed.tech/tags/arm.md>), [avx-512-vbmi](<https://devfeed.tech/tags/avx-512-vbmi.md>), [bug](<https://devfeed.tech/tags/bug.md>), [cve](<https://devfeed.tech/tags/cve.md>), [cve-2026-114938](<https://devfeed.tech/tags/cve-2026-114938.md>), [introduced](<https://devfeed.tech/tags/introduced.md>), [java4shell](<https://devfeed.tech/tags/java4shell.md>), [news](<https://devfeed.tech/tags/news.md>), [openjdk](<https://devfeed.tech/tags/openjdk.md>), [pr](<https://devfeed.tech/tags/pr.md>), [pull-request](<https://devfeed.tech/tags/pull-request.md>), [review](<https://devfeed.tech/tags/review.md>), [upstream](<https://devfeed.tech/tags/upstream.md>)

### AI overview

Aikido says Deep Review identified the Java4Shell flaw when run against a reconstruction of the 2021 OpenJDK pull request that introduced it. The excerpt explains that malformed Base64 padding could cause integer underflow in the AVX-512 decoder, producing an oversized write past the destination buffer; the vulnerable path is limited to x86-64 CPUs with AVX-512 VBMI support. Deep Review recommended falling back to the safer decoder when fewer than four input bytes remain, matching the upstream fix for this bug. It also reported two other defects, an oversized vector write and incomplete invalid-character validation, which the excerpt says were later corrected upstream. For mitigation, it recommends upgrading to listed patched Java releases; Aikido also offers patched Temurin 17 and 21 images for JDK and JRE use if upgrading is not yet possible, and describes dashboard and Attack Surface exposure checks.

### Source excerpt

We recreated the 2021 OpenJDK pull request behind Java4Shell (CVE-2026-114938) and ran Deep Review on it. It flagged the bug and suggested the upstream fix. Category: News

## Atlassian AI SDLC Index: Lower Code Costs Fail to Break Development Bottlenecks

DevFeed: [Atlassian AI SDLC Index: Lower Code Costs Fail to Break Development Bottlenecks](<https://devfeed.tech/articles/atlassian-ai-sdlc-index-lower-code-costs-fail-to-break-development-bottlenecks-141356.md>)

Original publisher: [Read original article](<https://sdtimes.com/ai-sdlc/atlassian-ai-sdlc-index-lower-code-costs-fail-to-break-development-bottlenecks/>)

Author: David Rubinstein

Published: 2026-11-18T17:00:45Z

Content type: news

Language: en

Sources: [SD Times](<https://devfeed.tech/sources/sd-times.md>)

Topics: [AI-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.md>), [atlassian](<https://devfeed.tech/topics/atlassian.md>), [Generative AI](<https://devfeed.tech/topics/generative-ai.md>), [ai code review](<https://devfeed.tech/topics/ai-code-review.md>), [Spec Driven Development](<https://devfeed.tech/topics/spec-driven-development.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [ai-code](<https://devfeed.tech/tags/ai-code.md>), [ai-coding](<https://devfeed.tech/tags/ai-coding.md>), [ai-generated-code](<https://devfeed.tech/tags/ai-generated-code.md>), [ai-sdlc](<https://devfeed.tech/tags/ai-sdlc.md>), [ai-tools](<https://devfeed.tech/tags/ai-tools.md>), [atlassian](<https://devfeed.tech/tags/atlassian.md>), [bottlenecks](<https://devfeed.tech/tags/bottlenecks.md>), [code](<https://devfeed.tech/tags/code.md>), [code-quality](<https://devfeed.tech/tags/code-quality.md>), [code-survivorship](<https://devfeed.tech/tags/code-survivorship.md>), [costs](<https://devfeed.tech/tags/costs.md>), [development](<https://devfeed.tech/tags/development.md>), [dx](<https://devfeed.tech/tags/dx.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [engineering-intelligence](<https://devfeed.tech/tags/engineering-intelligence.md>), [engineers](<https://devfeed.tech/tags/engineers.md>), [financial](<https://devfeed.tech/tags/financial.md>), [index](<https://devfeed.tech/tags/index.md>), [latest-news](<https://devfeed.tech/tags/latest-news.md>), [sdlc](<https://devfeed.tech/tags/sdlc.md>), [software](<https://devfeed.tech/tags/software.md>), [software-engineers](<https://devfeed.tech/tags/software-engineers.md>)

### AI overview

Atlassian's AI SDLC Index finds that cheaper AI code generation has not removed software delivery bottlenecks. Across data from more than 500 organizations, AI-generated code rose from 49% of merged code in April 2026 to 70% in October; AI spend per unit of output fell nearly 27%, while code survivorship rebounded 9 points to 68%. Human pull request reviews grew at their fastest month-over-month rate in October, and engineers still spent about 58% of their time building features, a share largely unchanged for nearly two years. The report says planning and documentation correlate most strongly with code quality, yet only about 62% of organizations rated those practices favorably. Atlassian recommends tracking code survivorship, improving specifications and documentation, and creating structured time for experimentation. The supplied excerpt says the index will be updated quarterly.

### Source excerpt

Artificial intelligence is rapidly driving down the financial cost of generating software code, yet it has not made the overall job of software engineers significantly easier. That is the central finding of the newly released Atlassian AI SDLC Index, which analyzed engineering intelligence data from more than 500 organizations via DX. The index lays bare... ... continue reading The post Atlassian AI SDLC Index: Lower Code Costs Fail to Break Development Bottlenecks appeared first on SD Times.

## AI-Powered Sashiko Introduces Experimental Patch Series Design Assessment

DevFeed: [AI-Powered Sashiko Introduces Experimental Patch Series Design Assessment](<https://devfeed.tech/articles/ai-powered-sashiko-introduces-experimental-patch-series-design-assessment-140542.md>)

Original publisher: [Read original article](<https://www.phoronix.com/news/Sashiko-0.9.4-Released>)

Author: Michael Larabel

Published: 2026-11-18T11:13:06Z

Content type: release

Language: en

Sources: [Phoronix](<https://devfeed.tech/sources/phoronix.md>)

Topics: [ai code review](<https://devfeed.tech/topics/ai-code-review.md>), [Code review](<https://devfeed.tech/topics/code-review.md>), [Linux](<https://devfeed.tech/topics/linux.md>), [model architecture](<https://devfeed.tech/topics/model-architecture.md>)

Tags: [ai-powered](<https://devfeed.tech/tags/ai-powered.md>), [assessment](<https://devfeed.tech/tags/assessment.md>), [code-review](<https://devfeed.tech/tags/code-review.md>), [design](<https://devfeed.tech/tags/design.md>), [desktop-linux](<https://devfeed.tech/tags/desktop-linux.md>), [experimental](<https://devfeed.tech/tags/experimental.md>), [linux-benchmarking](<https://devfeed.tech/tags/linux-benchmarking.md>), [linux-hardware-benchmarks](<https://devfeed.tech/tags/linux-hardware-benchmarks.md>), [linux-hardware-reviews](<https://devfeed.tech/tags/linux-hardware-reviews.md>), [linux-how-to](<https://devfeed.tech/tags/linux-how-to.md>), [linux-performance](<https://devfeed.tech/tags/linux-performance.md>), [linux-server-benchmarks](<https://devfeed.tech/tags/linux-server-benchmarks.md>), [open-source-graphics](<https://devfeed.tech/tags/open-source-graphics.md>), [patch](<https://devfeed.tech/tags/patch.md>), [phoronix](<https://devfeed.tech/tags/phoronix.md>), [phoronix-test-suite](<https://devfeed.tech/tags/phoronix-test-suite.md>), [review](<https://devfeed.tech/tags/review.md>), [series](<https://devfeed.tech/tags/series.md>), [ubuntu-benchmarks](<https://devfeed.tech/tags/ubuntu-benchmarks.md>), [ubuntu-hardware](<https://devfeed.tech/tags/ubuntu-hardware.md>)

### AI overview

Sashiko 0.9.4 adds an experimental `sashiko review --design` option for local reviews. Its four-stage pipeline assesses a patch series as a whole, complementing Sashiko's existing reviews of individual patches for correctness and other code shortcomings. The release also adds first-class code review support for e2fsprogs, the user-space utilities for EXT4 and earlier filesystems. The article describes the series assessment as experimental and does not report how it performs in practice.

### Source excerpt

When it comes to leveraging AI for Linux kernel development, one of the most widely-used solutions at the moment is Sashiko that has evolved nicely over the past year for agentic AI code review. This AI-driven screening of generated code posted to the Linux kernel mailing list constantly identifies bugs and other code defects in a quick and straight-forward manner. With being developed and maintained by Google engineers, it uses Gemini by default but is LLM-agnostic overall. Released on Tuesday was Sashiko v0.9.4 as the next step forward for this Linux kernel helper...

## LLMs as Validators for Cross-Chain Bridges: Evaluating Source-Level and Transaction-Level Attack Detection on Solana

DevFeed: [LLMs as Validators for Cross-Chain Bridges: Evaluating Source-Level and Transaction-Level Attack Detection on Solana](<https://devfeed.tech/articles/llms-as-validators-for-cross-chain-bridges-evaluating-source-level-and-transaction-level-attack-detection-on-solana-139905.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.21777>)

Author: Yasir Rahman, Ishraq Samiha, Shahnewaz Karim Sakib, Anindya Bijoy Das

Published: 2026-11-18T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>), [arXiv: Cryptography and Security](<https://devfeed.tech/sources/arxiv-cryptography-and-security.md>)

Topics: [Solana](<https://devfeed.tech/topics/solana.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [ai code review](<https://devfeed.tech/topics/ai-code-review.md>), [Security](<https://devfeed.tech/topics/security.md>), [code security](<https://devfeed.tech/topics/code-security.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [attack](<https://devfeed.tech/tags/attack.md>), [bridges](<https://devfeed.tech/tags/bridges.md>), [cross](<https://devfeed.tech/tags/cross.md>), [cross-chain-bridges](<https://devfeed.tech/tags/cross-chain-bridges.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [detection](<https://devfeed.tech/tags/detection.md>), [llms](<https://devfeed.tech/tags/llms.md>), [solana](<https://devfeed.tech/tags/solana.md>), [source](<https://devfeed.tech/tags/source.md>), [transaction](<https://devfeed.tech/tags/transaction.md>)

### AI overview

In tests of a native Rust lock-and-mint bridge on a local Solana validator, LLMs' ability to diagnose vulnerabilities depended strongly on the evidence provided. Without source comments, models correctly diagnosed 24% of vulnerable source inputs and frequently flagged the secure bridge; transaction diagnosis was high for the missing-signer flaw but averaged 6% across the other three scenarios. Including original comments, some of which described the flaw, raised source diagnosis to 60%. The evaluation covered four exploitable variants, six configurations of five open-weight models, and successful attacks, benign sessions, and blocked attempts, distinguishing correct diagnoses from unsupported alarms.

### Source excerpt

arXiv:2611.21777v1 Announce Type: cross Abstract: Cross-chain bridges have suffered substantial asset losses due to vulnerabilities in their on-chain programs. On Solana, missing validation checks can enable exploits even when the underlying blockchain operates correctly. The ability of large language models (LLMs) to diagnose these flaws from source code or transaction records, rather than merely raise alarms, remains insufficiently understood. We implement a native Rust lock-and-mint bridge on a local Solana validator with four exploitable variants: two model flaws from the Cashio and Wormhole incidents, while the other two represent vulnerability classes documented in Solana security audits. Paired vulnerable and secure programs, together with successful attacks, benign sessions, and blocked attempts, allow us to distinguish correct diagnoses from unsupported alarms. We evaluate six configurations of five open-weight models across 16,800 responses, compare source inputs with and without comments, and grade 7,200 answers on vulnerable inputs using two blinded LLM graders. The results reveal substantial differences across conditions: without comments, models diagnose 24% of vulnerable source inputs while frequently flagging the secure bridge. Transaction diagnosis is high for the missing-signer scenario but averages 6% across the other three scenarios. Original comments, some of which describe the flaw, increase source diagnosis to 60%. These findings highlight the importance of distinguishing correct vulnerability diagnoses from unsupported alarms in bridge security review.

## RTLReviewBench: LLM Hardware Reviewers Rarely Miss Bugs but Routinely Reject Correct RTL

DevFeed: [RTLReviewBench: LLM Hardware Reviewers Rarely Miss Bugs but Routinely Reject Correct RTL](<https://devfeed.tech/articles/rtlreviewbench-llm-hardware-reviewers-rarely-miss-bugs-but-routinely-reject-correct-rtl-141661.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.21678>)

Author: Yasir Mahmud

Published: 2026-11-18T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [ai code review](<https://devfeed.tech/topics/ai-code-review.md>), [Verilog](<https://devfeed.tech/topics/verilog.md>), [llm-reasoning](<https://devfeed.tech/topics/llm-reasoning.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Hallucination detection](<https://devfeed.tech/topics/hallucination-detection.md>)

Tags: [benchmark](<https://devfeed.tech/tags/benchmark.md>), [bugs](<https://devfeed.tech/tags/bugs.md>), [cs-ar](<https://devfeed.tech/tags/cs-ar.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [llm](<https://devfeed.tech/tags/llm.md>), [reasoning](<https://devfeed.tech/tags/reasoning.md>), [release](<https://devfeed.tech/tags/release.md>), [rtl](<https://devfeed.tech/tags/rtl.md>), [simulation](<https://devfeed.tech/tags/simulation.md>)

### AI overview

RTLReviewBench evaluates 12 commercial and open-weight models on 114 matched pairs of buggy and correct Verilog modules, with labels confirmed by simulation. Models rarely accept buggy code but frequently reject correct code, making more than five false rejections per missed bug. On the same designs, they miss fewer synthetic injected bugs than real bugs. For weaker reviewers, asking for reasoning before the verdict sharply reduces false rejections; an ablation finds reasoning placement matters more than the instruction to reason, while sampling and majority voting do not help. A blinded audit finds some correct "buggy" verdicts rely on false technical claims. The authors release the benchmark, a harder split, model responses, and evaluation code.

### Source excerpt

arXiv:2611.21678v1 Announce Type: cross Abstract: Hardware teams increasingly ask large language models (LLMs) to review register-transfer level (RTL) code, yet it is unclear whether a model can tell a correct module from a buggy one without simulating it. We introduce RTLReviewBench, a benchmark of 114 matched pairs of buggy and correct Verilog modules. Each pair shares one specification, most buggy modules are real failures of LLM code generators, and every label is confirmed by simulation. Evaluating 12 commercial and open-weight models, we find a consistent asymmetry: reviewers rarely accept buggy code but often reject correct code, producing more than five false rejections for every missed bug. Synthetic mutants hide part of the problem: on the same designs, models miss far fewer injected bugs than real ones. Asking a model to reason before it commits to a verdict sharply reduces false rejections for weaker reviewers, and a controlled ablation shows that where the reasoning appears in the output matters more than the instruction to reason, whereas sampling and majority voting do not help. A blinded audit further shows that some correct "buggy" verdicts rest on false technical claims. We release the benchmark, a harder split for future models, all model responses, and the evaluation code at https://github.com/yasirmahmud/RTLReviewBench

## We Fixed the Scorer First, and Cluster Correction Killed Our Own Planted-Defect Result in AI Code Review

DevFeed: [We Fixed the Scorer First, and Cluster Correction Killed Our Own Planted-Defect Result in AI Code Review](<https://devfeed.tech/articles/we-fixed-the-scorer-first-and-cluster-correction-killed-our-own-planted-defect-result-in-ai-code-review-139592.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.21635>)

Author: Sungjin Kwon

Published: 2026-11-18T05:00:00Z

Content type: opinion

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [ai code review](<https://devfeed.tech/topics/ai-code-review.md>), [Code review](<https://devfeed.tech/topics/code-review.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [ai-code](<https://devfeed.tech/tags/ai-code.md>), [ai-code-review](<https://devfeed.tech/tags/ai-code-review.md>), [automated](<https://devfeed.tech/tags/automated.md>), [axis](<https://devfeed.tech/tags/axis.md>), [case](<https://devfeed.tech/tags/case.md>), [cases](<https://devfeed.tech/tags/cases.md>), [cluster](<https://devfeed.tech/tags/cluster.md>), [code](<https://devfeed.tech/tags/code.md>), [code-review](<https://devfeed.tech/tags/code-review.md>), [contributions](<https://devfeed.tech/tags/contributions.md>), [controls](<https://devfeed.tech/tags/controls.md>), [cost](<https://devfeed.tech/tags/cost.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [defect](<https://devfeed.tech/tags/defect.md>), [defect-detection](<https://devfeed.tech/tags/defect-detection.md>), [defects](<https://devfeed.tech/tags/defects.md>), [delete](<https://devfeed.tech/tags/delete.md>), [first](<https://devfeed.tech/tags/first.md>), [fixed](<https://devfeed.tech/tags/fixed.md>), [review](<https://devfeed.tech/tags/review.md>)

### AI overview

A small AI code-review study found no statistically separable contrast after accounting for clustering across eight cases: two contrasts significant under an independence assumption had exact case-level permutation p-values of 0.0625 and 0.109, and neither survived Holm correction. The authors describe the result as unobservable with this design, not evidence of no effect; more cases, rather than repeated runs, are needed. A second pass had no paired losses but its gains were concentrated in one case, while byte-identical prompt baselines differed between runs (15/24 vs 20/24). The reported claim error rate was 0.0% (0/178), but the authors say this gives no upper bound and covers only claims retained by the policy, leaving dropped claims unmeasured. Pre-registered controls rejected 12/12 fabricated claims with no false rejections. They retract their original causal explanation and argue that automated verdicts should not control publish, delete, or history-rewrite actions; a mechanized refusal enforces that limit.

### Source excerpt

arXiv:2611.21635v1 Announce Type: new Abstract: Judging an AI code-review pipeline only by how much it catches hides an axis: what it dropped. Stronger selection raises precision for free; the cost never reaches the report. We ran four arms on the same eight cases, one scorer, asking whether planted-defect detection can rise without raising the claim error rate. Three repetitions are nested in eight cases, so p is reported per contrast and twice: under an exact permutation test over cases (2^8 arrangements) the two contrasts publishable under independence (Fisher p=0.017, 0.019) move to 0.0625 and 0.109, and after Holm correction no contrast separates. This is "not observable with this design," not "no effect": the sign test needs six discordant cases in one direction, its realized type-I rate under the null is 0.0078, and 80% power needs a per-case win probability near 0.80; closing it takes 12-25 cases, not repetitions. Within a run, a second pass never removes what the first found (0/24, 0/24 paired losses) while its gains (+3, +2) fall in one case; baselines on byte-identical prompts differed 15/24 vs 20/24, so run-to-run variance exceeds the effect. The claim error rate is 0.0% (0/178), with no upper bound on the rate claimed; scorer discrimination was measured with pre-registered positive controls (12/12 fabricated claims rejected, 0 false rejections). We retract our original causal explanation and report the instrument defects we hit. The contributions are not the numbers: (1) fixing the instrument before seeing results, then killing our own main effect with it; (2) the identity eps-hat = eps-hat(pi): a reported error rate is computed only on the subset a retention policy kept, silent about what was dropped, so it does not identify the quantity an irreversible gate needs; no improvement in the number promotes an automated verdict to publish, delete, or history-rewrite surfaces; a mechanized refusal enforces this.

## OpenAI's GPT-6.2 Astra and GPT-6.2 Sol now available

DevFeed: [OpenAI's GPT-6.2 Astra and GPT-6.2 Sol now available](<https://devfeed.tech/articles/openai-s-gpt-6-2-astra-and-gpt-6-2-sol-now-available-139403.md>)

Original publisher: [Read original article](<https://github.blog/changelog/2026-11-17-openais-gpt-6-2-astra-and-gpt-6-2-sol-now-available>)

Author: Allison

Published: 2026-11-17T20:20:29Z

Content type: release

Language: en

Sources: [GitHub Changelog](<https://devfeed.tech/sources/github-changelog.md>)

Topics: [gpt-6-astra](<https://devfeed.tech/topics/gpt-6-astra.md>), [GitHub Copilot](<https://devfeed.tech/topics/github-copilot.md>), [agentic-coding](<https://devfeed.tech/topics/agentic-coding.md>), [Code review](<https://devfeed.tech/topics/code-review.md>), [ai code review](<https://devfeed.tech/topics/ai-code-review.md>), [OpenAI](<https://devfeed.tech/topics/openai.md>)

Tags: [agentic](<https://devfeed.tech/tags/agentic.md>), [agentic-coding](<https://devfeed.tech/tags/agentic-coding.md>), [billing](<https://devfeed.tech/tags/billing.md>), [code-review](<https://devfeed.tech/tags/code-review.md>), [coding-agent](<https://devfeed.tech/tags/coding-agent.md>), [coding-tasks](<https://devfeed.tech/tags/coding-tasks.md>), [copilot](<https://devfeed.tech/tags/copilot.md>), [github](<https://devfeed.tech/tags/github.md>), [github-copilot](<https://devfeed.tech/tags/github-copilot.md>), [gpt-6-2-astra](<https://devfeed.tech/tags/gpt-6-2-astra.md>), [gpt-6-2-sol](<https://devfeed.tech/tags/gpt-6-2-sol.md>), [openai](<https://devfeed.tech/tags/openai.md>), [pricing](<https://devfeed.tech/tags/pricing.md>), [release](<https://devfeed.tech/tags/release.md>), [sol](<https://devfeed.tech/tags/sol.md>)

### AI overview

GPT-6.2 Astra and GPT-6.2 Sol are generally available in GitHub Copilot for Pro+, Max, Business, and Enterprise users, with a gradual rollout. Both target agentic coding and code review: Astra is also aimed at terminal work and completed tested coding tasks using noticeably fewer tokens than GPT-6 Astra; Sol targets complex coding and in-depth review, catching nearly twice as many real issues as GPT-6.1 Sol in early testing while keeping findings accurate. The post also reports that both caught significantly more real review issues than earlier GPT-6 models while using fewer tokens. They are billed at provider list pricing under usage-based billing, and can be selected in the listed Copilot clients. Business and Enterprise administrators manage access through model policy; new models are enabled by default unless global defaults are off or the models are explicitly disabled.

### Source excerpt

OpenAI's GPT-6.2 Astra and GPT-6.2 Sol are now generally available in GitHub Copilot. Both models are designed for agentic coding and code review, with stronger coding judgment than earlier GPT-6... The post OpenAI's GPT-6.2 Astra and GPT-6.2 Sol now available appeared first on The GitHub Blog.

## Track Copilot code review outcomes in Repository insights

DevFeed: [Track Copilot code review outcomes in Repository insights](<https://devfeed.tech/articles/track-copilot-code-review-outcomes-in-repository-insights-139404.md>)

Original publisher: [Read original article](<https://github.blog/changelog/2026-11-17-track-copilot-code-review-outcomes-in-repository-insights>)

Author: Allison

Published: 2026-11-17T18:00:35Z

Content type: release

Language: en

Sources: [GitHub Changelog](<https://devfeed.tech/sources/github-changelog.md>)

Topics: [ai code review](<https://devfeed.tech/topics/ai-code-review.md>), [Code review](<https://devfeed.tech/topics/code-review.md>), [Pull Request](<https://devfeed.tech/topics/pull-request.md>), [Repository](<https://devfeed.tech/topics/repository.md>)

Tags: [account-management](<https://devfeed.tech/tags/account-management.md>), [api](<https://devfeed.tech/tags/api.md>), [billing](<https://devfeed.tech/tags/billing.md>), [categories](<https://devfeed.tech/tags/categories.md>), [code-review](<https://devfeed.tech/tags/code-review.md>), [copilot](<https://devfeed.tech/tags/copilot.md>), [copilot-code](<https://devfeed.tech/tags/copilot-code.md>), [coverage](<https://devfeed.tech/tags/coverage.md>), [enterprise](<https://devfeed.tech/tags/enterprise.md>), [enterprise-management-tools](<https://devfeed.tech/tags/enterprise-management-tools.md>), [feedback](<https://devfeed.tech/tags/feedback.md>), [insights](<https://devfeed.tech/tags/insights.md>), [metrics](<https://devfeed.tech/tags/metrics.md>), [pull-request](<https://devfeed.tech/tags/pull-request.md>), [pull-requests](<https://devfeed.tech/tags/pull-requests.md>), [release](<https://devfeed.tech/tags/release.md>), [reports](<https://devfeed.tech/tags/reports.md>), [repositories](<https://devfeed.tech/tags/repositories.md>), [repository](<https://devfeed.tech/tags/repository.md>), [request](<https://devfeed.tech/tags/request.md>), [review](<https://devfeed.tech/tags/review.md>), [reviews](<https://devfeed.tech/tags/reviews.md>), [types](<https://devfeed.tech/tags/types.md>)

### AI overview

Repository insights adds a page in each repository's Insights tab that summarizes Copilot code review outcomes: comments and high-severity comments addressed, reviewed pull requests without a later human change request, and merged pull requests that lacked Copilot review. It also provides the addressed rate with its numerator, denominator, unevaluable exclusions, trend, and supported breakdowns, plus comment categories. The same metrics are available in enterprise and organization `repos-1-day` reports through the Copilot usage metrics API. Repository viewers can access the page; API reports require an eligible owner, billing manager, or custom role with `View Copilot Metrics`. The Copilot usage metrics policy must be enabled.

### Source excerpt

You can now see how Copilot code review feedback lands in each repository. A new "Repository insights" page, the first item in a repository's Insights tab, brings Copilot code review... The post Track Copilot code review outcomes in Repository insights appeared first on The GitHub Blog.

## Building a gated review pipeline for AI coding agents on AWS

DevFeed: [Building a gated review pipeline for AI coding agents on AWS](<https://devfeed.tech/articles/building-a-gated-review-pipeline-for-ai-coding-agents-on-aws-139358.md>)

Original publisher: [Read original article](<https://aws.amazon.com/blogs/devops/building-a-gated-review-pipeline-for-ai-coding-agents-on-aws/>)

Author: Owen Hawkins

Published: 2026-11-17T17:29:01Z

Content type: article

Language: en

Sources: [AWS DevOps & Developer Productivity Blog](<https://devfeed.tech/sources/aws-devops-developer-productivity-blog.md>)

Topics: [ai code review](<https://devfeed.tech/topics/ai-code-review.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>), [Code review](<https://devfeed.tech/topics/code-review.md>), [Pull Request](<https://devfeed.tech/topics/pull-request.md>), [Amazon Bedrock AgentCore](<https://devfeed.tech/topics/amazon-bedrock-agentcore.md>), [Amazon Bedrock](<https://devfeed.tech/topics/amazon-bedrock.md>), [Static code analysis](<https://devfeed.tech/topics/static-code-analysis.md>)

Tags: [acceptance-rate](<https://devfeed.tech/tags/acceptance-rate.md>), [access-management](<https://devfeed.tech/tags/access-management.md>), [advanced-300](<https://devfeed.tech/tags/advanced-300.md>), [agent-hooks](<https://devfeed.tech/tags/agent-hooks.md>), [agent-skills](<https://devfeed.tech/tags/agent-skills.md>), [agentcore-runtime](<https://devfeed.tech/tags/agentcore-runtime.md>), [ai-coding-agents](<https://devfeed.tech/tags/ai-coding-agents.md>), [amazon-athena](<https://devfeed.tech/tags/amazon-athena.md>), [amazon-bedrock-agentcore](<https://devfeed.tech/tags/amazon-bedrock-agentcore.md>), [amazon-bedrock-knowledge-bases](<https://devfeed.tech/tags/amazon-bedrock-knowledge-bases.md>), [amazon-cloudwatch](<https://devfeed.tech/tags/amazon-cloudwatch.md>), [amazon-eventbridge](<https://devfeed.tech/tags/amazon-eventbridge.md>), [amazon-simple-storage-service-amazon-s3](<https://devfeed.tech/tags/amazon-simple-storage-service-amazon-s3.md>), [amazon-sns](<https://devfeed.tech/tags/amazon-sns.md>), [application-security-testing](<https://devfeed.tech/tags/application-security-testing.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [aws](<https://devfeed.tech/tags/aws.md>), [best-practices](<https://devfeed.tech/tags/best-practices.md>), [kiro](<https://devfeed.tech/tags/kiro.md>), [pipeline](<https://devfeed.tech/tags/pipeline.md>), [policy](<https://devfeed.tech/tags/policy.md>), [review](<https://devfeed.tech/tags/review.md>), [risk](<https://devfeed.tech/tags/risk.md>)

### AI overview

The article proposes a six-control pipeline to manage the review bottleneck created by AI coding agents: centralize versioned standards; run deterministic checks with bounded agent self-correction; use a diverse AI review panel whose findings are checked against code and semantically verified; apply risk-tiered merge policy in a deterministic gate; preserve human approval with review depth matched to risk; and validate generated tests and operational recommendations after merge. On AWS, it maps these controls to services including AgentCore, CodeBuild, S3, Lambda, CodePipeline, EventBridge, and Athena. The panel advises but does not approve or block; humans retain consequential decisions. Rollout starts with a four-week quality baseline, then deterministic gates, an advisory panel, and only later blocking policy after findings earn trust. Measure review time alongside defect escape, rework, stability, panel quality, change size, and cost, since faster decisions alone may not improve quality.

### Source excerpt

AI coding agents generate code faster than humans can review it. This post lays out a gated review pipeline of six controls that pairs deterministic checks with a verified AI review panel, applies risk-tiered policy gates, and keeps humans in charge of every consequential decision, with a concrete AWS implementation for each control.

## Agents didn't break code review, they exposed it

DevFeed: [Agents didn't break code review, they exposed it](<https://devfeed.tech/articles/agents-didn-t-break-code-review-they-exposed-it-140703.md>)

Original publisher: [Read original article](<https://www.sonarsource.com/blog/ai-code-verification-has-to-scale-past-the-human-reviewer/>)

Author: Brooks Naylor

Published: 2026-11-17T14:00:00Z

Content type: article

Language: en

Sources: [Sonar Blog](<https://devfeed.tech/sources/sonar-blog.md>)

Topics: [Code review](<https://devfeed.tech/topics/code-review.md>), [ai code review](<https://devfeed.tech/topics/ai-code-review.md>), [Static code analysis](<https://devfeed.tech/topics/static-code-analysis.md>), [Pull Request](<https://devfeed.tech/topics/pull-request.md>), [AI-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.md>), [qualitygates](<https://devfeed.tech/topics/qualitygates.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-code-verification](<https://devfeed.tech/tags/ai-code-verification.md>), [code](<https://devfeed.tech/tags/code.md>), [code-review](<https://devfeed.tech/tags/code-review.md>), [code-verification](<https://devfeed.tech/tags/code-verification.md>), [human-review](<https://devfeed.tech/tags/human-review.md>), [llm](<https://devfeed.tech/tags/llm.md>), [scale](<https://devfeed.tech/tags/scale.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

As agents increase the volume of code, delivery pressure can leave changes insufficiently reviewed, while large pull requests already made human approval an unreliable safeguard. John Crickett argues that neither human review nor an LLM should be the sole quality gate: LLM review is cheap and repeatable but inconsistent, so it adds value as one layer rather than as the final authority. He recommends pairing it with deterministic checks--static analysis, compiler checks, tests, and exploratory testing. These checks can consistently verify rules such as syntax, data flows, architecture, and dependencies; agentic verification can reason about intent and business logic that rules cannot establish. The layers should run independently of the code-generating agent and leave auditable evidence of intent, standards, checks, and results. The text also notes that even excellent code can implement the wrong requirement, so code quality alone does not establish that a system meets its intended needs.

### Source excerpt

Human review can't keep pace with agents. Learn how AI code verification pairs LLM review with deterministic analysis to scale, with John Crickett.

## The illusion of AI productivity in software development and what to measure instead

DevFeed: [The illusion of AI productivity in software development and what to measure instead](<https://devfeed.tech/articles/the-illusion-of-ai-productivity-in-software-development-and-what-to-measure-instead-137003.md>)

Original publisher: [Read original article](<https://www.cio.com/article/4249152/the-illusion-of-ai-productivity-in-software-development-and-what-to-measure-instead.html>)

Author: Nazar Yaremchuk

Published: 2026-11-17T09:00:00Z

Content type: article

Language: en

Sources: [CIO](<https://devfeed.tech/sources/cio.md>)

Topics: [AI-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.md>), [developer-productivity](<https://devfeed.tech/topics/developer-productivity.md>), [ai code review](<https://devfeed.tech/topics/ai-code-review.md>), [Code review](<https://devfeed.tech/topics/code-review.md>), [human review](<https://devfeed.tech/topics/human-review.md>), [qualitygates](<https://devfeed.tech/topics/qualitygates.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>), [GitHub](<https://devfeed.tech/topics/github.md>), [Azure DevOps](<https://devfeed.tech/topics/azure-devops.md>), [Jenkins](<https://devfeed.tech/topics/jenkins.md>)

Tags: [accenture](<https://devfeed.tech/tags/accenture.md>), [adoption](<https://devfeed.tech/tags/adoption.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-adoption](<https://devfeed.tech/tags/ai-adoption.md>), [ai-assisted](<https://devfeed.tech/tags/ai-assisted.md>), [ai-coding-tools](<https://devfeed.tech/tags/ai-coding-tools.md>), [ai-generated-code](<https://devfeed.tech/tags/ai-generated-code.md>), [ai-investments](<https://devfeed.tech/tags/ai-investments.md>), [ai-productivity](<https://devfeed.tech/tags/ai-productivity.md>), [artificial-intelligence](<https://devfeed.tech/tags/artificial-intelligence.md>), [artificial-intelligence-it-leadership-roi-and-metrics](<https://devfeed.tech/tags/artificial-intelligence-it-leadership-roi-and-metrics.md>), [automation](<https://devfeed.tech/tags/automation.md>), [azure-devops](<https://devfeed.tech/tags/azure-devops.md>), [bain](<https://devfeed.tech/tags/bain.md>), [bain-co](<https://devfeed.tech/tags/bain-co.md>), [cios](<https://devfeed.tech/tags/cios.md>), [code](<https://devfeed.tech/tags/code.md>), [coding-tools](<https://devfeed.tech/tags/coding-tools.md>), [contributor](<https://devfeed.tech/tags/contributor.md>), [development](<https://devfeed.tech/tags/development.md>), [edition-us](<https://devfeed.tech/tags/edition-us.md>), [it-leadership](<https://devfeed.tech/tags/it-leadership.md>), [language-en](<https://devfeed.tech/tags/language-en.md>), [productivity](<https://devfeed.tech/tags/productivity.md>), [roi-and-metrics](<https://devfeed.tech/tags/roi-and-metrics.md>), [software](<https://devfeed.tech/tags/software.md>), [software-development](<https://devfeed.tech/tags/software-development.md>), [storytype-opinion](<https://devfeed.tech/tags/storytype-opinion.md>)

### AI overview

AI code generation can shift effort into review and rework, so adoption or code volume alone does not show productivity gains. The source cites a Bain report finding developers completed about 21% more tasks while time spent reviewing outputs rose 91%. It recommends tracking engineering cycle time, idea-to-deployment lead time, review and rework time, and software quality, using a baseline and assessing the measures together. At Pearl, AI generated GitHub Actions workflows despite the team using Azure DevOps and Jenkins; the mismatch required a rewrite. Pearl describes AI-assisted review with human oversight scaled to risk: AI can primarily review lower-risk changes such as unit tests, while critical production code still gets human review. For AI agents, the source also calls for clear permissions, responsibilities, and oversight, and argues that workflows should be redesigned around AI while preserving human judgment where needed.

### Source excerpt

Accenture reports that 82% of C-suite leaders are increasing AI investments, signaling continued confidence in the technology. But if you talk to tech leaders, the returns aren't so clear-cut. AI can write code in seconds, but that's only the first stage of software development. When AI-generated output introduces errors, misses internal requirements or requires extensive rework, the time saved upfront can quickly disappear. A report from Bain & Co validates this -- AI coding tools are helping developers complete roughly 21% more tasks, but time spent reviewing outputs rose 91%. As engineers generate more code, senior developers face growing review queues. AI can also produce lengthy specifications and documentation that take time to evaluate. This obscures the impact AI adoption is having on the software development lifecycle and, much of the time, simply creates more work. To understand whether AI is improving productivity, CIOs need to look at the entire process, from the initial idea to software in production. Building quality controls At Pearl, we've experienced similar aforementioned challenges when using AI to automate parts of our software development process. For example, we asked AI to help create pipeline automation, but it generated GitHub Actions workflows for an engineering environment that uses Azure DevOps and Jenkins. Our astute engineers caught the mismatch during review and had to rewrite the integration. The code was plausible, but it didn't account for our actual infrastructure. This is a clear example of how AI-generated code can be convincing despite lacking important context. To catch these instances before advancing too far in the development process, we have a quality-control process that combines AI-assisted review with human oversight based on risk. Lower-risk changes, such as unit tests, can often be reviewed primarily by AI, while critical production-facing code still receives human review. Our AI reviews identify an average of 16 errors

## Too many instructions can hold back AI security audits

DevFeed: [Too many instructions can hold back AI security audits](<https://devfeed.tech/articles/too-many-instructions-can-hold-back-ai-security-audits-136726.md>)

Original publisher: [Read original article](<https://www.helpnetsecurity.com/2026/11/17/peter-stockli-github-ai-security-audits/>)

Author: Mirko Zorz

Published: 2026-11-17T07:00:54Z

Content type: news

Language: en

Sources: [Help Net Security](<https://devfeed.tech/sources/help-net-security.md>)

Topics: [ai code review](<https://devfeed.tech/topics/ai-code-review.md>), [Security research](<https://devfeed.tech/topics/security-research.md>), [Prompt Engineering](<https://devfeed.tech/topics/prompt-engineering.md>), [ai security](<https://devfeed.tech/topics/ai-security.md>), [Access Control](<https://devfeed.tech/topics/access-control.md>), [GitHub](<https://devfeed.tech/topics/github.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agentic-ai](<https://devfeed.tech/tags/agentic-ai.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [ai-security](<https://devfeed.tech/tags/ai-security.md>), [application-security](<https://devfeed.tech/tags/application-security.md>), [audit](<https://devfeed.tech/tags/audit.md>), [audits](<https://devfeed.tech/tags/audits.md>), [authentication](<https://devfeed.tech/tags/authentication.md>), [authorization](<https://devfeed.tech/tags/authorization.md>), [bugs](<https://devfeed.tech/tags/bugs.md>), [cybersecurity](<https://devfeed.tech/tags/cybersecurity.md>), [don-t-miss](<https://devfeed.tech/tags/don-t-miss.md>), [false-positives](<https://devfeed.tech/tags/false-positives.md>), [features](<https://devfeed.tech/tags/features.md>), [github](<https://devfeed.tech/tags/github.md>), [hot-stuff](<https://devfeed.tech/tags/hot-stuff.md>), [instructions](<https://devfeed.tech/tags/instructions.md>), [interview](<https://devfeed.tech/tags/interview.md>), [maintainers](<https://devfeed.tech/tags/maintainers.md>), [model](<https://devfeed.tech/tags/model.md>), [modeling](<https://devfeed.tech/tags/modeling.md>), [news](<https://devfeed.tech/tags/news.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [opinion](<https://devfeed.tech/tags/opinion.md>), [prompts](<https://devfeed.tech/tags/prompts.md>), [report](<https://devfeed.tech/tags/report.md>), [security](<https://devfeed.tech/tags/security.md>), [strategy](<https://devfeed.tech/tags/strategy.md>), [threat-modeling](<https://devfeed.tech/tags/threat-modeling.md>)

### AI overview

GitHub's AI audit taskflows began with authentication and authorization vulnerabilities, where missing or inconsistent access checks can reveal bugs. The agent first maps components, entry points, user actions, and intended behavior; researchers sometimes add data from other sources, but rarely discard the threat model and start over. Task design and prompting vary by model: prompts are tested, and instructions are removed when they add no benefit, since overprompting can limit creativity. A security researcher manually validates every report, confirms it is report-worthy, filters lower-severity findings, and sends a proof of concept showing impact. GitHub says this review and follow-up support a 95% fix rate. To ease maintainer triage, it cites rate limits, structured reporting forms, and API improvements.

### Source excerpt

In this Help Net Security interview, Peter Stöckli, Security Researcher at GitHub, explains how the team uses AI agents to audit software for vulnerabilities. The discussion covers why the work started with authentication and authorization bugs, how prompts are tested and trimmed for each model, and what the agent produces during threat modeling. Stöckli also describes how every report is checked by a person before it reaches maintainers, how false positives are filtered out, and ... More -> The post Too many instructions can hold back AI security audits appeared first on Help Net Security.

## AI Cannot Review What Humans Catch: A First Look at the Reviews of Agent Instruction Files

DevFeed: [AI Cannot Review What Humans Catch: A First Look at the Reviews of Agent Instruction Files](<https://devfeed.tech/articles/ai-cannot-review-what-humans-catch-a-first-look-at-the-reviews-of-agent-instruction-files-137967.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.18582>)

Author: Wenhao Yang, Runzhi He, Minghui Zhou

Published: 2026-11-17T05:00:00Z

Content type: news

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [human review](<https://devfeed.tech/topics/human-review.md>), [ai code review](<https://devfeed.tech/topics/ai-code-review.md>), [Pull Request](<https://devfeed.tech/topics/pull-request.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Code review](<https://devfeed.tech/topics/code-review.md>)

Tags: [1-3](<https://devfeed.tech/tags/1-3.md>), [abstract](<https://devfeed.tech/tags/abstract.md>), [act](<https://devfeed.tech/tags/act.md>), [agent](<https://devfeed.tech/tags/agent.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [attention](<https://devfeed.tech/tags/attention.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [but](<https://devfeed.tech/tags/but.md>), [can](<https://devfeed.tech/tags/can.md>), [categories](<https://devfeed.tech/tags/categories.md>), [change](<https://devfeed.tech/tags/change.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [files](<https://devfeed.tech/tags/files.md>), [first](<https://devfeed.tech/tags/first.md>), [first-look](<https://devfeed.tech/tags/first-look.md>), [humans](<https://devfeed.tech/tags/humans.md>), [look](<https://devfeed.tech/tags/look.md>), [review](<https://devfeed.tech/tags/review.md>), [reviews](<https://devfeed.tech/tags/reviews.md>)

### AI overview

Across 2,870 instruction-file pull requests from 2,246 repositories, over 70% received no substantive review. The study treats files such as AGENTS.md, CLAUDE.md, .cursorrules, and SKILL.md as executable policy that can redirect agent behavior, while lacking the automated checks available for code. It reports a 16-category taxonomy of review concerns and a benchmark of 1,962 human-checked concerns across 468 pull requests. Tested against that benchmark with full repository access, Codex, OpenCode, and Claude Code recovered only 1.3-3.9% of concerns raised by humans; the abstract says they catch surface structure but miss factual errors, necessity, and staleness. The findings suggest these agents cannot replace human attention in reviewing instruction-file changes.

### Source excerpt

arXiv:2611.18582v1 Announce Type: new Abstract: Agents increasingly shape software, and instruction files steer them. Files such as AGENTS.md, CLAUDE.md, .cursorrules, and SKILL.md act as executable policy: prose that a machine reads and acts on. Unlike ordinary documentation, a single edit to one of these files can silently redirect how an agent behaves across an entire repository. Natural-language rules have no per-change oracle, so they slip past the compilers, type-checkers, and test suites that guard code. Review is therefore the only quality gate, but no prior work has studied how that review happens. We analyzed 2,870 instruction-file pull requests across 2,246 repositories. The gate is largely broken: over 70% of instruction-file changes receive no substantive review. When an AI reviewer substitutes for a human, it is structurally blind to the concerns that most need human judgment. It catches surface structure but misses factual errors, necessity questions, and staleness problems. We contribute the first taxonomy of instruction-file review concerns (16 categories), which exposes this sharp human/AI divergence, and a benchmark of 1,962 human-checked concerns across 468 PRs. We ran three widely-used agents (Codex, OpenCode, and Claude Code) against the benchmark, giving each reviewer the full repository at review time. They recovered only 1.3-3.9% of the concerns humans raise. Even the strongest current agents cannot substitute for human attention on these files.

## Level Up! AI-Driven Challenges and Adaptations to Code Review Practices

DevFeed: [Level Up! AI-Driven Challenges and Adaptations to Code Review Practices](<https://devfeed.tech/articles/level-up-ai-driven-challenges-and-adaptations-to-code-review-practices-137975.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.18939>)

Author: Kaia Newman, Christian Bird, Jenna Butler, Emerson Murphy-Hill

Published: 2026-11-17T05:00:00Z

Content type: news

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Code review](<https://devfeed.tech/topics/code-review.md>), [Pull Request](<https://devfeed.tech/topics/pull-request.md>), [ai code review](<https://devfeed.tech/topics/ai-code-review.md>), [engineering-culture](<https://devfeed.tech/topics/engineering-culture.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [ai-assisted](<https://devfeed.tech/tags/ai-assisted.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [attention](<https://devfeed.tech/tags/attention.md>), [authoring](<https://devfeed.tech/tags/authoring.md>), [bottleneck](<https://devfeed.tech/tags/bottleneck.md>), [can](<https://devfeed.tech/tags/can.md>), [challenges](<https://devfeed.tech/tags/challenges.md>), [changes](<https://devfeed.tech/tags/changes.md>), [code](<https://devfeed.tech/tags/code.md>), [code-review](<https://devfeed.tech/tags/code-review.md>), [company](<https://devfeed.tech/tags/company.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [design](<https://devfeed.tech/tags/design.md>), [developers](<https://devfeed.tech/tags/developers.md>), [practices](<https://devfeed.tech/tags/practices.md>), [review](<https://devfeed.tech/tags/review.md>), [up](<https://devfeed.tech/tags/up.md>)

### AI overview

A mixed-methods study at a large multinational software company (24 interviews and a 2,590-person survey) found that AI-assisted coding shifts reviewers toward design and intent while adding review burden through reduced author stewardship and larger or more numerous pull requests, with potential downstream debt. Use of AI for review was not correlated with less difficulty keeping up with pull request volume, so it alone did not resolve the challenge. Developers identified organizational support and resourcing for review, moving review work upstream, and focusing reviewer attention on the most important concerns as useful strategies.

### Source excerpt

arXiv:2611.18939v1 Announce Type: new Abstract: AI can write code faster than humans can review, causing a bottleneck and necessitating changes to code review practices. This bottleneck is hotly debated, giving rise to two extreme and orthogonal imagined futures: one where humans continue to be firmly entrenched in the review process, and one where AI agents merge pull requests entirely without human involvement. Yet, these futures remain rooted in folk wisdom. Through a mixed-methods study of interviews ($n = 24$) and a survey ($n = 2{,}590$) at a large, multinational software company with widespread access to AI, we identify AI-driven code review challenges and strategies reported as effective to meet them. We found that AI enables, necessitates, and complicates a shift in the human reviewer's role toward high-level concerns (e.g., design and intent). We found that AI-assisted authoring results in increased burden for reviewers due to challenges such as a lack of author stewardship and PR volume and size, potentially leading to downstream debt. Our survey showed AI review usage was not correlated with less difficulty keeping up with PR volume, indicating using AI for review alone is not sufficient for solving AI-driven review challenges. Developers found the most useful strategies to be organizations supporting and resourcing review, pushing review burden upstream, and prioritizing reviewer attention on the concerns that matter most.

## The hard part of AI coding is deciding what to keep

DevFeed: [The hard part of AI coding is deciding what to keep](<https://devfeed.tech/articles/the-hard-part-of-ai-coding-is-deciding-what-to-keep-135978.md>)

Original publisher: [Read original article](<https://coderabbit.ai/blog/the-merge-ryan-vogel-deciding-what-to-keep>)

Author: Hendrik Krack

Published: 2026-11-16T18:12:39.425207Z

Content type: article

Language: en

Sources: [CodeRabbit](<https://devfeed.tech/sources/coderabbit.md>)

Topics: [Code review](<https://devfeed.tech/topics/code-review.md>), [Pull Request](<https://devfeed.tech/topics/pull-request.md>), [human review](<https://devfeed.tech/topics/human-review.md>), [ai code review](<https://devfeed.tech/topics/ai-code-review.md>), [engineering-culture](<https://devfeed.tech/topics/engineering-culture.md>), [codex](<https://devfeed.tech/topics/codex.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-coding](<https://devfeed.tech/tags/ai-coding.md>), [api](<https://devfeed.tech/tags/api.md>), [app](<https://devfeed.tech/tags/app.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [bug](<https://devfeed.tech/tags/bug.md>), [business-logic](<https://devfeed.tech/tags/business-logic.md>), [caching](<https://devfeed.tech/tags/caching.md>), [challenge](<https://devfeed.tech/tags/challenge.md>), [code-generation](<https://devfeed.tech/tags/code-generation.md>), [code-review](<https://devfeed.tech/tags/code-review.md>), [coding](<https://devfeed.tech/tags/coding.md>), [collaboration](<https://devfeed.tech/tags/collaboration.md>), [comment](<https://devfeed.tech/tags/comment.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [english](<https://devfeed.tech/tags/english.md>), [featured](<https://devfeed.tech/tags/featured.md>), [pr](<https://devfeed.tech/tags/pr.md>), [review](<https://devfeed.tech/tags/review.md>)

### AI overview

The harder part of AI-written code is deciding whether a change belongs, not merely reviewing whether it passes. Ryan Vogel recommends stating the app's needs, challenging unnecessary architecture, and using a separate agent to check intermediate work against the original direction. For code review, Harjot Gill says CodeRabbit reconstructs change order and reviews from data and schema through logic and APIs to interface and tests, helping reviewers trace dependencies. The discussion also favors testable evidence over confident claims: an agent should be able to ask questions or run checks, and suspected bugs should be tested before becoming findings. Clear-end tasks suit agents better; open-ended design needs more frequent human decisions. Handoffs should expose decisions, dependencies, evidence, and remaining human judgment, with review effort scaled to a change's consequences.

### Source excerpt

A PR can pass review while nobody decides if the change belongs. Harjot Gill and Ryan Vogel discuss engineering judgment in agent-written code.

## PrivacyPR: A Dataset of Real-World Privacy Fixes for Benchmarking Privacy-Aware Code Review

DevFeed: [PrivacyPR: A Dataset of Real-World Privacy Fixes for Benchmarking Privacy-Aware Code Review](<https://devfeed.tech/articles/privacypr-a-dataset-of-real-world-privacy-fixes-for-benchmarking-privacy-aware-code-review-135184.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.18293>)

Author: Hua Yang, Aditya Bhardwaj, Shidong Pan, Bowen Xu

Published: 2026-11-16T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>), [arXiv: Cryptography and Security](<https://devfeed.tech/sources/arxiv-cryptography-and-security.md>), [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [ai code review](<https://devfeed.tech/topics/ai-code-review.md>), [Code review](<https://devfeed.tech/topics/code-review.md>), [Pull Request](<https://devfeed.tech/topics/pull-request.md>)

Tags: [code-review](<https://devfeed.tech/tags/code-review.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [dataset](<https://devfeed.tech/tags/dataset.md>), [privacy](<https://devfeed.tech/tags/privacy.md>)

### AI overview

PrivacyPR offers 4,131 merged GitHub pull requests from 1,469 repositories (2018-2024) for studying privacy fixes and benchmarking privacy-aware code review. It includes 1,169 high-confidence privacy fixes, 1,643 non-fix PRs, a manually checked 500-PR Verified split, and a 200-PR Small evaluation subset. On Verified, both annotators endorsed 72% of the LLM-assigned GDPR principles. In the Small benchmark, two coding agents detected 42-51% of defects with a generic review prompt and 88-91% when explicitly asked to check privacy; they also flagged 11-15% of non-fix PRs. The results indicate that detection depends strongly on review intent and includes false alarms. The harness reverts fixes to reintroduce defects.

### Source excerpt

arXiv:2611.18293v1 Announce Type: cross Abstract: Coding agents increasingly review code, yet whether they catch the privacy defects that laws such as the GDPR require software to avoid remains largely untested, partly because few datasets connect real privacy defects to their accepted fixes and review context. We present PrivacyPR, a dataset of 4,131 merged GitHub pull requests (PRs) from 1,469 repositories, created between June 2018 and January 2024. Each PR includes its commits, diffs, review discussion, and LLM-generated labels for privacy relevance, fix type, and GDPR principles. PrivacyPR provides 1,169 high-confidence privacy fixes and 1,643 non-fix PRs, together with Verified, a manually checked split of 250 privacy fixes and 250 non-fix PRs, and Small, a 100 + 100 subset for evaluation. On Verified, both annotators endorsed 72% of the LLM's GDPR-principle assignments. Beyond supporting empirical study of how privacy defects arise and are fixed, PrivacyPR provides a benchmark for privacy-aware code review on real, developer-accepted fixes. Its evaluation harness reverts each fix to reintroduce the defect. On Small, two coding agents detect only 42-51% of defects under a generic review prompt, but 88-91% when explicitly asked to check privacy, while flagging 11-15% of non-fix PRs. These results show that privacy defects can be detected by coding agents, but that detection depends strongly on review intent and comes with false alarms. Data, code, reviews, judge verdicts, and an extensible evaluation harness are publicly available at https://doi.org/10.5281/zenodo.23744765.

## Anthropic Outlines Its AI-Powered Code Review Process for Claude Code

DevFeed: [Anthropic Outlines Its AI-Powered Code Review Process for Claude Code](<https://devfeed.tech/articles/anthropic-outlines-its-ai-powered-code-review-process-for-claude-code-134364.md>)

Original publisher: [Read original article](<https://www.infoq.com/news/2026/11/claude-code-review/>)

Author: Robert Krzaczyński

Published: 2026-11-15T09:55:00Z

Content type: news

Language: en

Sources: [InfoQ](<https://devfeed.tech/sources/infoq.md>)

Topics: [ai code review](<https://devfeed.tech/topics/ai-code-review.md>), [Code review](<https://devfeed.tech/topics/code-review.md>), [human review](<https://devfeed.tech/topics/human-review.md>), [Pull Request](<https://devfeed.tech/topics/pull-request.md>), [Claude Code](<https://devfeed.tech/topics/claude-code.md>), [Claude](<https://devfeed.tech/topics/claude.md>), [software security audit](<https://devfeed.tech/topics/software-security-audit.md>), [feature flags](<https://devfeed.tech/topics/feature-flags.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [ai-coding-agents](<https://devfeed.tech/tags/ai-coding-agents.md>), [ai-ml-data-engineering](<https://devfeed.tech/tags/ai-ml-data-engineering.md>), [ai-powered](<https://devfeed.tech/tags/ai-powered.md>), [anthropic](<https://devfeed.tech/tags/anthropic.md>), [automated](<https://devfeed.tech/tags/automated.md>), [claude](<https://devfeed.tech/tags/claude.md>), [claude-code](<https://devfeed.tech/tags/claude-code.md>), [claude-code-review](<https://devfeed.tech/tags/claude-code-review.md>), [code](<https://devfeed.tech/tags/code.md>), [code-review](<https://devfeed.tech/tags/code-review.md>), [code-reviews](<https://devfeed.tech/tags/code-reviews.md>), [incidents](<https://devfeed.tech/tags/incidents.md>), [layers](<https://devfeed.tech/tags/layers.md>), [manual-review](<https://devfeed.tech/tags/manual-review.md>), [ml-data-engineering](<https://devfeed.tech/tags/ml-data-engineering.md>), [news](<https://devfeed.tech/tags/news.md>), [process](<https://devfeed.tech/tags/process.md>), [production](<https://devfeed.tech/tags/production.md>), [reduce](<https://devfeed.tech/tags/reduce.md>), [regressions](<https://devfeed.tech/tags/regressions.md>), [risk](<https://devfeed.tech/tags/risk.md>), [team](<https://devfeed.tech/tags/team.md>)

### AI overview

Anthropic's Claude Code team shifts much verification earlier and assigns human approval by change risk. Before a pull request, Claude runs tests, builds, and linters, while a separate agent reviews the change; automated reviewers then investigate potential bugs, and a security review can block unresolved issues. Low-risk changes may need no human approval, medium-risk changes need one approver, and high-risk changes need two; sensitive areas such as CI workflows always receive human oversight. Review cycles are capped at three rounds, with later rounds focused on new changes. Anthropic reports that from June to September merged pull requests more than doubled while the share requiring a revert fell over 40%; one-round pass rates rose from 65% to 78%, and reviews requiring five or more rounds fell from 8.9% to 1.5%. Humans remain accountable for architecture, product direction, high-risk changes, and final outcomes. Merged changes are typically released behind feature flags, tested internally, and gradually rolled out; incidents and reverts feed an evaluation dataset for improving reviewers.

### Source excerpt

Anthropic has outlined how the Claude Code team handles code reviews as AI agents increasingly contribute to its codebase. The approach relies on multiple layers of automated verification, AI-powered reviews, and risk-based human approval, aiming to reduce manual review time without increasing regressions or production incidents. By Robert Krzaczyński

## Take Claude Code Above Average: Let Antigravity Review It

DevFeed: [Take Claude Code Above Average: Let Antigravity Review It](<https://devfeed.tech/articles/take-claude-code-above-average-let-antigravity-review-it-132382.md>)

Original publisher: [Read original article](<https://medium.com/google-developer-experts/take-claude-code-above-average-let-antigravity-review-it-a945412e7dcf?source=rss----a67bd6fa7d58---4>)

Author: Daniel Gwerzman

Published: 2026-11-13T14:21:02Z

Content type: opinion

Language: en

Sources: [Google Developer Experts](<https://devfeed.tech/sources/google-developer-experts-medium.md>)

Topics: [Code review](<https://devfeed.tech/topics/code-review.md>), [ai code review](<https://devfeed.tech/topics/ai-code-review.md>), [Claude Code](<https://devfeed.tech/topics/claude-code.md>), [google-antigravity](<https://devfeed.tech/topics/google-antigravity.md>), [MSP MCP](<https://devfeed.tech/topics/msp-mcp.md>), [Claude](<https://devfeed.tech/topics/claude.md>), [codex](<https://devfeed.tech/topics/codex.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agent](<https://devfeed.tech/tags/ai-agent.md>), [antigravity](<https://devfeed.tech/tags/antigravity.md>), [bridge](<https://devfeed.tech/tags/bridge.md>), [claude](<https://devfeed.tech/tags/claude.md>), [claude-code](<https://devfeed.tech/tags/claude-code.md>), [code](<https://devfeed.tech/tags/code.md>), [code-review](<https://devfeed.tech/tags/code-review.md>), [design](<https://devfeed.tech/tags/design.md>), [gemini](<https://devfeed.tech/tags/gemini.md>), [gemini-4-argon](<https://devfeed.tech/tags/gemini-4-argon.md>), [google-antigravity](<https://devfeed.tech/tags/google-antigravity.md>), [google-developer-expert](<https://devfeed.tech/tags/google-developer-expert.md>), [november-2026](<https://devfeed.tech/tags/november-2026.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [process](<https://devfeed.tech/tags/process.md>), [review](<https://devfeed.tech/tags/review.md>), [security](<https://devfeed.tech/tags/security.md>), [stage](<https://devfeed.tech/tags/stage.md>), [tests](<https://devfeed.tech/tags/tests.md>)

### AI overview

The author's central finding is that independent review works best as a dialogue between different AI tools and models, with a human resolving disagreements. In the described setup, Claude Code leads while Antigravity with Gemini 4 Argon reviews; a second review caught concurrent-session risk and missing backups, and later discussion exposed a proposed fix that would fail from a subfolder. The four-stage loop briefs an outside reviewer, requests structured findings and evidence for assumptions, lets the author challenge findings once, then sends changes back for verification and escalates unresolved questions. The author's agy-bridge MCP server connects Claude Code to Antigravity's headless `agy` CLI, preserving review conversations and backing up and comparing project state each turn. Reviewers can read files and run tests but are instructed to write only in scratch space; shell commands cannot be similarly restricted, and project `.agents/` skills may steer review, so the author advises checking them in untrusted repositories. The method is intended for consequential work; reviews take minutes and are unnecessary for throwaway tasks.

### Source excerpt

In November 2026, I spent a day building a small tool with Claude Code: a bridge that lets a second AI agent review Claude's work, run the tests in my project, and argue about what it finds. Partway through the day, the design was revised, the code was written, the tests passed, and Claude was satisfied with its work. Then I gave the same design and code to a different model, running in a different tool. It came back with two findings marked high. Two terminal windows could drive the same review at the same time, each starting its own process behind the other's back. And the reviewer could run shell commands in my project, but nothing backed up my uncommitted work before its turn. One stray git reset --hard would have wiped it. Both were real. Both were cheap to fix. Neither was the kind of thing the author finds by "double-checking". That was the first fix of the day. There were two more. One more thing about that reviewer. It wasn't a second Claude session. It was Antigravity, Google's agentic development platform, running a Gemini model. Today, every review I run goes to Gemini 4 Argon. That pairing is what this article is about: why Claude Code does better work when Antigravity reviews it, the four-stage review I run between them, and the open-source bridge I built so Claude Code can call Antigravity on its own. Why the Author Can't Be the Reviewer Start with what these models are. They learned from everything people have put online: the brilliant answer and the one that ships a security hole, the masterpiece and the first draft. They learned the distribution. So by default, they give you the middle of it. Ask for a function and you get the average function: it works on the happy path and carries the usual number of subtle problems. That isn't a flaw. It's the mathematics of the system. Average is the floor, not the ceiling. The same model has seen far better work than the average. But getting it there takes a process, not a cleverer prompt. The second thing to

## Vercel Security Review no longer requires a linked Vercel project

DevFeed: [Vercel Security Review no longer requires a linked Vercel project](<https://devfeed.tech/articles/vercel-security-review-no-longer-requires-a-linked-vercel-project-133378.md>)

Original publisher: [Read original article](<https://vercel.com/changelog/vercel-security-review-no-longer-requires-a-linked-vercel-project>)

Author: Karim Rahal

Published: 2026-11-13T00:00:00Z

Content type: release

Language: en

Sources: [Vercel News](<https://devfeed.tech/sources/vercel-news.md>)

Topics: [ai code review](<https://devfeed.tech/topics/ai-code-review.md>), [software security audit](<https://devfeed.tech/topics/software-security-audit.md>), [code security](<https://devfeed.tech/topics/code-security.md>), [GitHub](<https://devfeed.tech/topics/github.md>), [Vercel](<https://devfeed.tech/topics/vercel.md>)

Tags: [account](<https://devfeed.tech/tags/account.md>), [agent](<https://devfeed.tech/tags/agent.md>), [app](<https://devfeed.tech/tags/app.md>), [automatically](<https://devfeed.tech/tags/automatically.md>), [changes](<https://devfeed.tech/tags/changes.md>), [code](<https://devfeed.tech/tags/code.md>), [commits](<https://devfeed.tech/tags/commits.md>), [connect](<https://devfeed.tech/tags/connect.md>), [context](<https://devfeed.tech/tags/context.md>), [coverage](<https://devfeed.tech/tags/coverage.md>), [covers](<https://devfeed.tech/tags/covers.md>), [deployment](<https://devfeed.tech/tags/deployment.md>), [documentation](<https://devfeed.tech/tags/documentation.md>), [git](<https://devfeed.tech/tags/git.md>), [github](<https://devfeed.tech/tags/github.md>), [limit](<https://devfeed.tech/tags/limit.md>), [project](<https://devfeed.tech/tags/project.md>), [review](<https://devfeed.tech/tags/review.md>), [security](<https://devfeed.tech/tags/security.md>), [vercel](<https://devfeed.tech/tags/vercel.md>)

### AI overview

Vercel Security Review can scan code changes in GitHub repositories that are not linked to a Vercel project. By default, it covers all unlinked repositories accessible to the Vercel GitHub App in a connected account; coverage can be narrowed to selected accounts or repositories in Agent settings. Once enabled, each push triggers a review. Reviews run directly on commits without a project or deployment, while pushes that create deployments for linked projects with Security Review enabled receive additional project and deployment context. Setup requires connecting the GitHub account in team Git settings and enabling Security Review in Vercel Agent settings.

### Source excerpt

You can now scan code changes for vulnerabilities with Vercel Security Review in GitHub repositories that have not yet been linked to a Vercel project. By default, Security Review covers all unlinked repositories the Vercel GitHub App can access in a connected GitHub account. You can limit coverage to selected connected accounts or individual repositories in Agent settings. Once enabled, each push to a covered repository automatically triggers a review of its code changes. Security Review checks commits directly in repositories with Security Review enabled, without requiring a Vercel project or deployment. When a push creates a deployment for a linked project with Security Review enabled, the review uses the additional project and deployment context. Connect the account in your team's Git settings, then enable Security Review in Vercel Agent settings. Get started with the Security Review documentation. Read more

## CodeRabbit Passes $100 million in ARR

DevFeed: [CodeRabbit Passes $100 million in ARR](<https://devfeed.tech/articles/coderabbit-passes-100-million-in-arr-130674.md>)

Original publisher: [Read original article](<https://coderabbit.ai/blog/coderabbit-100-million-arr>)

Author: Harjot Gill

Published: 2026-11-12T12:00:00Z

Content type: release

Language: en

Sources: [CodeRabbit](<https://devfeed.tech/sources/coderabbit.md>)

Topics: [ai code review](<https://devfeed.tech/topics/ai-code-review.md>), [code security](<https://devfeed.tech/topics/code-security.md>), [Loop Engineering](<https://devfeed.tech/topics/loop-engineering.md>), [Pull Request](<https://devfeed.tech/topics/pull-request.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [3](<https://devfeed.tech/tags/3.md>), [about](<https://devfeed.tech/tags/about.md>), [added](<https://devfeed.tech/tags/added.md>), [administration](<https://devfeed.tech/tags/administration.md>), [adoption](<https://devfeed.tech/tags/adoption.md>), [after](<https://devfeed.tech/tags/after.md>), [agent](<https://devfeed.tech/tags/agent.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [agentic-loop](<https://devfeed.tech/tags/agentic-loop.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-adoption](<https://devfeed.tech/tags/ai-adoption.md>), [ai-generated-code](<https://devfeed.tech/tags/ai-generated-code.md>), [ai-native](<https://devfeed.tech/tags/ai-native.md>), [ai-powered](<https://devfeed.tech/tags/ai-powered.md>), [announcements](<https://devfeed.tech/tags/announcements.md>), [annual-recurring-revenue](<https://devfeed.tech/tags/annual-recurring-revenue.md>), [english](<https://devfeed.tech/tags/english.md>), [featured](<https://devfeed.tech/tags/featured.md>), [just](<https://devfeed.tech/tags/just.md>), [over](<https://devfeed.tech/tags/over.md>), [revenue](<https://devfeed.tech/tags/revenue.md>)

### AI overview

CodeRabbit says its annual recurring revenue grew from $10 million to $100 million in just over a year. It reports more than 20,000 customers, 400,000 monthly active users, and over 3 million pull requests reviewed weekly; the average team ships at twice its previous rate. The product provides an independent AI review layer that assesses changes for issues, standards, architectural fit, and risk, with monitoring after merge. The company argues this helps teams validate agent-written code as quickly as it is generated, while keeping review separate from the code-writing agent. It has added OpenAI GPT Cyber models to CodeRabbit Secure and reports that an initial free-scan program found over 43,000 critical or high-severity findings across 13,000 scans. CodeRabbit is also available through several AI providers' marketplaces and says its review pipeline is model-agnostic.

### Source excerpt

CodeRabbit has grown from $10 million to $100 million in annual recurring revenue in just over a year.

## New Edge archive offers opt-in AI-driven security remediation and backports

DevFeed: [New Edge archive offers opt-in AI-driven security remediation and backports](<https://devfeed.tech/articles/new-edge-archive-offers-opt-in-ai-driven-security-remediation-and-backports-130262.md>)

Original publisher: [Read original article](<https://canonical.com//blog/new-edge-archive-offers-opt-in-ai-driven-security-remediation-and-backports>)

Author: Canonical

Published: 2026-11-12T09:56:47Z

Content type: release

Language: en

Sources: [Canonical](<https://devfeed.tech/sources/canonical.md>)

Topics: [agentic workflows](<https://devfeed.tech/topics/agentic-workflows.md>), [code security](<https://devfeed.tech/topics/code-security.md>), [Security](<https://devfeed.tech/topics/security.md>), [ai code review](<https://devfeed.tech/topics/ai-code-review.md>), [Test automation](<https://devfeed.tech/topics/test-automation.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [ai-driven-security](<https://devfeed.tech/tags/ai-driven-security.md>), [archive](<https://devfeed.tech/tags/archive.md>), [attacks](<https://devfeed.tech/tags/attacks.md>), [backports](<https://devfeed.tech/tags/backports.md>), [can](<https://devfeed.tech/tags/can.md>), [customers](<https://devfeed.tech/tags/customers.md>), [ecosystem](<https://devfeed.tech/tags/ecosystem.md>), [edge](<https://devfeed.tech/tags/edge.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [large](<https://devfeed.tech/tags/large.md>), [more](<https://devfeed.tech/tags/more.md>), [number](<https://devfeed.tech/tags/number.md>), [offers](<https://devfeed.tech/tags/offers.md>), [open](<https://devfeed.tech/tags/open.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [remediation](<https://devfeed.tech/tags/remediation.md>), [security](<https://devfeed.tech/tags/security.md>), [ubuntu-pro](<https://devfeed.tech/tags/ubuntu-pro.md>)

### AI overview

Ubuntu Pro users can opt into the new Edge archive to test machine-generated CVE fixes before qualification and general release. The fixes are produced by Surge, which maps vulnerabilities to Ubuntu packages, gathers upstream context, generates competing backports, and uses independent models to judge divergent candidates. Low-confidence cases or deadlocked votes go to Ubuntu security engineers; accepted patches are built and deterministically tested. Edge is a preview, not a change to security policy: stable Ubuntu security updates remain human-validated, and Surge does not cover kernel CVEs. Kernel fixes follow a separate two-week SRU cycle, with proposed kernels available for testing and a week of soak testing plus certification across Ubuntu-certified hardware before promotion to -updates.

### Source excerpt

The open source ecosystem faces an unprecedented wave of vulnerability reports and attacks, driven by AI agents. Our security teams have already shipped double the number of security fixes that they did last year. However, human engineering and review processes, as well as large-scale soak testing, take more time than some users and customers can [...]

[Next page](<https://devfeed.tech/topics/ai-code-review.md?cursor=WyIyMDI2LTExLTEyVDA5OjU2OjQ3KzAwOjAwIiwgIjEzYWFmYzA3LTdjM2EtNDc3Mi1hYjIzLTNlNzVkYWU4NzNlZSJd>)