# Code review

Code review is the review of code changes that helps teams catch issues early and maintain code quality.

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

## Anthropic says Claude writes and reviews 90% of its team's code. The catch is how it checks the work.

DevFeed: [Anthropic says Claude writes and reviews 90% of its team's code. The catch is how it checks the work.](<https://devfeed.tech/articles/anthropic-says-claude-writes-and-reviews-90-of-its-team-s-code-the-catch-is-how-it-checks-the-work-146429.md>)

Original publisher: [Read original article](<https://thenewstack.io/anthropic-claude-code-verification/>)

Author: Amanda Caswell

Published: 2026-11-20T16:41:28Z

Content type: news

Language: en

Sources: [The New Stack](<https://devfeed.tech/sources/the-new-stack.md>)

Topics: [Claude Code](<https://devfeed.tech/topics/claude-code.md>), [Claude](<https://devfeed.tech/topics/claude.md>), [Code review](<https://devfeed.tech/topics/code-review.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>), [anthropic](<https://devfeed.tech/topics/anthropic.md>), [ui-testing](<https://devfeed.tech/topics/ui-testing.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [ai-code](<https://devfeed.tech/tags/ai-code.md>), [anthropic](<https://devfeed.tech/tags/anthropic.md>), [browser-automation](<https://devfeed.tech/tags/browser-automation.md>), [claude](<https://devfeed.tech/tags/claude.md>), [claude-code](<https://devfeed.tech/tags/claude-code.md>), [code-review](<https://devfeed.tech/tags/code-review.md>), [cost](<https://devfeed.tech/tags/cost.md>), [defects](<https://devfeed.tech/tags/defects.md>), [developer-tools](<https://devfeed.tech/tags/developer-tools.md>), [differential-testing](<https://devfeed.tech/tags/differential-testing.md>), [evaluations](<https://devfeed.tech/tags/evaluations.md>), [false-negative](<https://devfeed.tech/tags/false-negative.md>), [false-positive](<https://devfeed.tech/tags/false-positive.md>), [software-testing](<https://devfeed.tech/tags/software-testing.md>)

### AI overview

Anthropic says Claude produces roughly 90% of the code from the Claude Code team, supported by a verification system that runs inexpensive deterministic checks--builds, linters, and tests--before using model review for questions tests cannot answer. Agents exercise changes in running apps through browser automation, mobile simulators, or local services. To guard against test manipulation, reviewers read rules from the base branch and results apply only to the exact commit examined; failing tests cannot simply be skipped or rerun until they pass. Engineers review evidence and take over after three unsuccessful rounds. Anthropic reports that merged pull requests more than doubled from June to September while the share later reverted fell by over 40%, but does not attribute the change to verification or publish model-review error rates or specific inference costs.

### Source excerpt

Anthropic says Claude writes and reviews roughly 90% of the code produced by the team building Claude Code, and the The post Anthropic says Claude writes and reviews 90% of its team's code. The catch is how it checks the work. appeared first on The New Stack.

## JetBrains Air in GoLand: Build, Review, and Profile Go Code With Agents

DevFeed: [JetBrains Air in GoLand: Build, Review, and Profile Go Code With Agents](<https://devfeed.tech/articles/jetbrains-air-in-goland-build-review-and-profile-go-code-with-agents-146493.md>)

Original publisher: [Read original article](<https://blog.jetbrains.com/go/2026/11/20/jetbrains-air-in-goland/>)

Author: Dominika Stankiewicz

Published: 2026-11-20T14:13:09Z

Content type: tutorial

Language: en

Sources: [JetBrains](<https://devfeed.tech/sources/the-jetbrains-blog.md>)

Topics: [goland](<https://devfeed.tech/topics/goland.md>), [codex](<https://devfeed.tech/topics/codex.md>), [Code review](<https://devfeed.tech/topics/code-review.md>), [junie](<https://devfeed.tech/topics/junie.md>), [Spec Driven Development](<https://devfeed.tech/topics/spec-driven-development.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [air](<https://devfeed.tech/tags/air.md>), [backend](<https://devfeed.tech/tags/backend.md>), [event](<https://devfeed.tech/tags/event.md>), [go](<https://devfeed.tech/tags/go.md>), [goland](<https://devfeed.tech/tags/goland.md>), [handler](<https://devfeed.tech/tags/handler.md>), [jetbrains](<https://devfeed.tech/tags/jetbrains.md>), [jetbrains-air](<https://devfeed.tech/tags/jetbrains-air.md>), [profile](<https://devfeed.tech/tags/profile.md>), [request](<https://devfeed.tech/tags/request.md>), [review](<https://devfeed.tech/tags/review.md>), [services](<https://devfeed.tech/tags/services.md>), [store](<https://devfeed.tech/tags/store.md>), [webhook](<https://devfeed.tech/tags/webhook.md>)

### AI overview

The article demonstrates using JetBrains Air in GoLand 2026.3 to build and verify a signed Go webhook receiver with coding agents. It recommends defining the service requirements first, reviewing agent diffs for security and idempotency issues, and assigning independent follow-up tasks to separate worktrees before combining and checking them with GoLand's HTTP and database tools. Air supports Junie, Codex, Claude Code, and other Agent Client Protocol agents, with session controls for model, effort, and access. The bundled `goland-profiler` skill lets supported agents capture and inspect profiles. In the example, profiling identifies per-request regular-expression compilation in `validateEventID` as the hot path; moving compilation to package initialization yields a reported 4.6x faster benchmark, 59% fewer bytes, and 80% fewer allocations per request, with timing varying by machine.

### Source excerpt

If you've ever built backend services in Go, chances are you've also written a webhook handler or two. They're small and rarely get much attention - that is, until something breaks. A third-party provider sends a signed request, and then you check the signature, store the event, and reply. Sounds like three easy steps, but [...]

## 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.

## Producing Healthy Code with Artificial Intelligence Costs Fewer Tokens

DevFeed: [Producing Healthy Code with Artificial Intelligence Costs Fewer Tokens](<https://devfeed.tech/articles/producing-healthy-code-with-artificial-intelligence-costs-fewer-tokens-143689.md>)

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

Author: Ben Linders

Published: 2026-11-19T11:09:00Z

Content type: news

Language: en

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

Topics: [Code Health](<https://devfeed.tech/topics/code-health.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [clean-code](<https://devfeed.tech/topics/clean-code.md>), [Code Modularity](<https://devfeed.tech/topics/code-modularity.md>), [Code review](<https://devfeed.tech/topics/code-review.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>)

Tags: [agentic](<https://devfeed.tech/tags/agentic.md>), [agentic-ai](<https://devfeed.tech/tags/agentic-ai.md>), [agentic-development-lifecycle](<https://devfeed.tech/tags/agentic-development-lifecycle.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-coding-agents](<https://devfeed.tech/tags/ai-coding-agents.md>), [ai-cost-optimisation](<https://devfeed.tech/tags/ai-cost-optimisation.md>), [artificial-intelligence](<https://devfeed.tech/tags/artificial-intelligence.md>), [better](<https://devfeed.tech/tags/better.md>), [but](<https://devfeed.tech/tags/but.md>), [can](<https://devfeed.tech/tags/can.md>), [clean-code](<https://devfeed.tech/tags/clean-code.md>), [code](<https://devfeed.tech/tags/code.md>), [code-health](<https://devfeed.tech/tags/code-health.md>), [code-quality](<https://devfeed.tech/tags/code-quality.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [costs](<https://devfeed.tech/tags/costs.md>), [culture-methods](<https://devfeed.tech/tags/culture-methods.md>), [data](<https://devfeed.tech/tags/data.md>), [development](<https://devfeed.tech/tags/development.md>), [feedback](<https://devfeed.tech/tags/feedback.md>), [fewer](<https://devfeed.tech/tags/fewer.md>), [goto-conference](<https://devfeed.tech/tags/goto-conference.md>), [health](<https://devfeed.tech/tags/health.md>), [healthy-code-ai-tokens](<https://devfeed.tech/tags/healthy-code-ai-tokens.md>), [large-language-models](<https://devfeed.tech/tags/large-language-models.md>), [mcp](<https://devfeed.tech/tags/mcp.md>), [means](<https://devfeed.tech/tags/means.md>), [measurement](<https://devfeed.tech/tags/measurement.md>), [metrics](<https://devfeed.tech/tags/metrics.md>), [news](<https://devfeed.tech/tags/news.md>), [refactoring](<https://devfeed.tech/tags/refactoring.md>), [speed](<https://devfeed.tech/tags/speed.md>), [tokens](<https://devfeed.tech/tags/tokens.md>), [up](<https://devfeed.tech/tags/up.md>), [with](<https://devfeed.tech/tags/with.md>)

### AI overview

The excerpt reports that agentic coding can initially raise velocity, but a study of 1,000+ open-source projects found those gains were erased after two months as code complexity grew. Adam Tornhill argues that healthier code helps AI perform better and use 40%-45% fewer tokens. In the described tests, Claude alone fixed about half of code health issues in lower-health code and correctly refactored only 20% once health improved; giving agents code health data through an MCP raised the reported fix rate to 90%-100%. For refactoring at scale, the interview recommends measuring a baseline, establishing a reliable test safety net, and using iterative feedback based on code health and test results. Safeguards such as linting, coverage, mutation testing, and code health metrics should be automated and exposed through MCP servers or command-line tools. The excerpt says module-level quality automation is largely solved, while design and architecture remain challenges.

### Source excerpt

Agentic AI can speed up velocity, but the gains vanish within months as code complexity grows. Healthy code makes AI perform better and costs fewer tokens. Safeguarding means keeping code health high through agentic refactoring, with an MCP supplying code health data, so AI can maintain the code it generates. By Ben Linders

## How OpenAI's Performance Factory keeps ChatGPT fast

DevFeed: [How OpenAI's Performance Factory keeps ChatGPT fast](<https://devfeed.tech/articles/how-openai-s-performance-factory-keeps-chatgpt-fast-145835.md>)

Original publisher: [Read original article](<https://openai.com/index/how-openai-performance-factory-keeps-chatgpt-fast>)

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

Content type: article

Language: en

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

Topics: [performance-engineering](<https://devfeed.tech/topics/performance-engineering.md>), [codex](<https://devfeed.tech/topics/codex.md>), [Monitoring](<https://devfeed.tech/topics/monitoring.md>), [Production Engineering](<https://devfeed.tech/topics/production-engineering.md>), [Code review](<https://devfeed.tech/topics/code-review.md>), [ChatGPT](<https://devfeed.tech/topics/chatgpt.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>)

Tags: [chatgpt](<https://devfeed.tech/tags/chatgpt.md>), [codex](<https://devfeed.tech/tags/codex.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [factory](<https://devfeed.tech/tags/factory.md>), [fast](<https://devfeed.tech/tags/fast.md>), [openai](<https://devfeed.tech/tags/openai.md>), [performance](<https://devfeed.tech/tags/performance.md>), [workflows](<https://devfeed.tech/tags/workflows.md>)

### AI overview

OpenAI's Performance Factory automates performance regression work from alert to post-deployment verification, while keeping engineers involved in reviewing and merging fixes. A cloud dispatch system assigns Codex agents to tasks that preserve findings across steps and can resume after events such as code review or deployment. Agents use the `perf-forensics` skill and production telemetry to locate when slowdowns began, identify affected requests, examine changes, and propose fixes. Separate Codex reviews challenge diagnoses and fixes; engineers make decisions that require service context or tradeoff judgment. In a manual review of 100 root-cause suggestions, 70% were accurate, while 30% needed refinement or did not fully establish causality. In just over three months, the workflow tracked more than 1,700 investigations and root-caused over 600 cases. OpenAI also backtests investigations and task summaries, monitors agent tool failures, and is exploring proactive detection and agent-implemented low-risk fixes.

### Source excerpt

Learn how OpenAI built the Performance Factory, a system of Codex-powered workflows that finds and fixes performance issues to help keep ChatGPT fast.

## 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

## Everything after code, as code

DevFeed: [Everything after code, as code](<https://devfeed.tech/articles/everything-after-code-as-code-140948.md>)

Original publisher: [Read original article](<https://www.pulumi.com/blog/everything-after-code-as-code/>)

Author: Joe Duffy

Published: 2026-11-18T13:30:00Z

Content type: release

Language: en

Sources: [Pulumi](<https://devfeed.tech/sources/pulumi.md>)

Topics: [CI/CD](<https://devfeed.tech/topics/cicd.md>), [pulumi](<https://devfeed.tech/topics/pulumi.md>), [Continuous Delivery (CD)](<https://devfeed.tech/topics/continuous-delivery.md>), [Production Engineering](<https://devfeed.tech/topics/production-engineering.md>), [policy-as-code](<https://devfeed.tech/topics/policy-as-code.md>), [Code review](<https://devfeed.tech/topics/code-review.md>), [Git](<https://devfeed.tech/topics/git.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [agentic-coding](<https://devfeed.tech/tags/agentic-coding.md>), [agentic-sdlc](<https://devfeed.tech/tags/agentic-sdlc.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [anthropic](<https://devfeed.tech/tags/anthropic.md>), [bottleneck](<https://devfeed.tech/tags/bottleneck.md>), [ci](<https://devfeed.tech/tags/ci.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>), [codex](<https://devfeed.tech/tags/codex.md>), [coding](<https://devfeed.tech/tags/coding.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [continuous-delivery](<https://devfeed.tech/tags/continuous-delivery.md>), [delivery](<https://devfeed.tech/tags/delivery.md>), [frontier](<https://devfeed.tech/tags/frontier.md>), [git](<https://devfeed.tech/tags/git.md>), [merge](<https://devfeed.tech/tags/merge.md>), [model](<https://devfeed.tech/tags/model.md>), [product](<https://devfeed.tech/tags/product.md>), [product-launches](<https://devfeed.tech/tags/product-launches.md>), [pulumi-cloud](<https://devfeed.tech/tags/pulumi-cloud.md>)

### AI overview

Pulumi introduces two public-preview products to extend agentic workflows beyond code merge. Pulumi Delivery defines release pipelines as code in TypeScript, Python, HCL, Go, C#, Java, or YAML, with stages, gates, approvals, policy, secrets, and support for existing tools including Pulumi, Terraform, OpenTofu, and Ansible; it works alongside existing CI for build and test. Pulumi Agents monitor systems through events from PagerDuty, Datadog, Sentry, and Honeycomb or scheduled runs, using provided or custom agents. Agents have separate identities, least-privilege roles, and short-lived credentials, and submit proposed production changes as pull requests with deterministic plans checked against existing policies rather than changing production directly. Together, pipelines can promote low-risk changes automatically while routing riskier ones to human approval, and agent fixes return through the same gated release process. Both products are available in public preview in every Pulumi Cloud edition, including Free.

### Source excerpt

Introducing Pulumi Delivery and Pulumi Agents: agentic code to production, and back again. At Pulumi, we like code. A lot. And we aren't the only ones: agents like it too. This year, the share of infrastructure operations on Pulumi done by agents went from zero in January to over 40% in October. Anything expressed as code (infrastructure, policy, configuration) is something an agent can work on. Today we're extending that to everything after the merge with two launches: Pulumi Delivery, which lets you and your agents write delivery pipelines as code, and Pulumi Agents, customizable agents that watch your running systems and act when something goes wrong. Together, they take agentic code to production, and back again. I honestly can't remember a launch since Pulumi 1.0 that our customers and team have been this excited about. TypeSafe AI bet on Pulumi to scale Jev, their decision model, to over a trillion tokens per day using the engineering practices they already had. What happens after the merge Frontier labs have made huge advances in agentic coding, code review, and everything up to the merge. Claude Code, Codex, and friends now write and test a growing share of the code we ship, and the labs felt it first. Anthropic's monorepo went from about 2,500 merges a day in May to over 30,000 by September. At OpenAI, where one engineer now has several changes ready for CI at once, Git reliability at times fell below 90% under the load. Both rebuilt source control to keep up. And then it all stops at the pull request. Everything after the merge (provisioning, configuration, secrets, policy, and delivery) still runs on scripts, tickets, and waiting. Today's SDLC was designed for human hands working at human speed, and it has become the bottleneck. An agentic SDLC needs agentic delivery, too. We set out to answer a few questions. How does code get to production, and which gates does it pass through? Which of those gates need a human, and which can an agent handle? When somet

## 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...

## AI Made Writing Code Cheap. Getting It Reviewed Now Takes 5x Longer, Says LinearB's CEO

DevFeed: [AI Made Writing Code Cheap. Getting It Reviewed Now Takes 5x Longer, Says LinearB's CEO](<https://devfeed.tech/articles/ai-made-writing-code-cheap-getting-it-reviewed-now-takes-5x-longer-says-linearb-s-ceo-140467.md>)

Original publisher: [Read original article](<https://hackernoon.com/ai-made-writing-code-cheap-getting-it-reviewed-now-takes-5x-longer-says-linearbs-ceo?source=rss>)

Author: Ishan Pandey

Published: 2026-11-18T10:29:49Z

Content type: news

Language: en

Sources: [HackerNoon](<https://devfeed.tech/sources/hackernoon.md>)

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

Tags: [2016](<https://devfeed.tech/tags/2016.md>), [2019](<https://devfeed.tech/tags/2019.md>), [2022](<https://devfeed.tech/tags/2022.md>), [2025](<https://devfeed.tech/tags/2025.md>), [2026](<https://devfeed.tech/tags/2026.md>), [2027](<https://devfeed.tech/tags/2027.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-and-ml](<https://devfeed.tech/tags/ai-and-ml.md>), [ai-code](<https://devfeed.tech/tags/ai-code.md>), [business](<https://devfeed.tech/tags/business.md>), [ceo](<https://devfeed.tech/tags/ceo.md>), [code](<https://devfeed.tech/tags/code.md>), [coding](<https://devfeed.tech/tags/coding.md>), [coding-agents](<https://devfeed.tech/tags/coding-agents.md>), [context](<https://devfeed.tech/tags/context.md>), [good-company](<https://devfeed.tech/tags/good-company.md>), [linearb](<https://devfeed.tech/tags/linearb.md>), [ori-keren](<https://devfeed.tech/tags/ori-keren.md>), [return](<https://devfeed.tech/tags/return.md>), [review](<https://devfeed.tech/tags/review.md>), [software-development](<https://devfeed.tech/tags/software-development.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>), [software-review](<https://devfeed.tech/tags/software-review.md>), [technology](<https://devfeed.tech/tags/technology.md>), [writing](<https://devfeed.tech/tags/writing.md>), [writing-code](<https://devfeed.tech/tags/writing-code.md>)

### AI overview

LinearB's analysis says AI speeds code creation but shifts delays downstream: in its benchmarks of 8.1 million pull requests from 4,800 teams, agent-opened pull requests waited 17.6 hours for first review versus 3.4 hours for human ones, and AI-assisted changes were about 2.6 times larger. CEO Ori Keren says agents lack delivery and business context, so LinearB rebuilt its platform around a knowledge graph linking tickets, code, incidents, ownership and releases. Its planned agent skills use that context to guide effort by change risk and help determine where human review is needed. For AI return, Keren recommends measuring cost per effective delivered change--people and token spending divided by changes that merged, shipped and did not return as rework--and tracking model cost against code quality. He advises against using raw throughput or AI adoption rates as proof of return. The excerpt reports Emburse's cost per effective pull request fell about 35% over seven months as most of its code moved to AI; these are company-reported examples, not a guarantee of results.

### Source excerpt

LinearB CEO Ori Keren on why AI code waits longer for review, how boards should judge AI's return and why context now steers coding agents.

## The Software Engineering Factory: Engineering Accountability and Control in the Age of Abundant Code

DevFeed: [The Software Engineering Factory: Engineering Accountability and Control in the Age of Abundant Code](<https://devfeed.tech/articles/the-software-engineering-factory-engineering-accountability-and-control-in-the-age-of-abundant-code-139582.md>)

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

Author: Ahmed E. Hassan, Zhe Chen, Amr E. Mohamed, Keheliya Gallaba, Daniel German, Waleed Kadous, Gustavo A. Oliva, Radin Shayanfar, Paul Stack, Haoxiang Zhang

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

Content type: article

Language: en

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

Topics: [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [AI Engineering](<https://devfeed.tech/topics/ai-engineering.md>), [qualitygates](<https://devfeed.tech/topics/qualitygates.md>), [responsible-ai](<https://devfeed.tech/topics/responsible-ai.md>), [Code review](<https://devfeed.tech/topics/code-review.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>)

Tags: [acceptance](<https://devfeed.tech/tags/acceptance.md>), [accountability](<https://devfeed.tech/tags/accountability.md>), [agent](<https://devfeed.tech/tags/agent.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [building](<https://devfeed.tech/tags/building.md>), [changes](<https://devfeed.tech/tags/changes.md>), [code](<https://devfeed.tech/tags/code.md>), [code-review](<https://devfeed.tech/tags/code-review.md>), [community](<https://devfeed.tech/tags/community.md>), [control](<https://devfeed.tech/tags/control.md>), [controls](<https://devfeed.tech/tags/controls.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [dark-factory](<https://devfeed.tech/tags/dark-factory.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [factory](<https://devfeed.tech/tags/factory.md>), [software](<https://devfeed.tech/tags/software.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>)

### AI overview

The paper argues that when AI agents produce more code than people can review line by line, accountability should be built into the process rather than rely primarily on final code review. Its Software Engineering Factory uses protocols to define work stages, required evidence, and ownership; a deterministic engine written in conventional code enforces transitions and gates, with human escalation where needed. Humans retain authority by setting delegation scope, boundaries, escalation conditions, and decisions requiring judgment, without supervising every agent action. Drawing on three iterated implementations, two open source, the authors offer ten principles for designing and operating such systems. They present these as a non-exhaustive conceptual scaffold, not the only viable foundation.

### Source excerpt

arXiv:2611.21623v1 Announce Type: new Abstract: AI agents can now plan, write, test, review, and revise code at a volume no human organization can inspect line by line. Final code review therefore cannot remain the primary organizational control for owning code changes. The Software Engineering (SE) Factory moves control into the process that produces the code. The Factory protocols define how work moves, what evidence must exist before it can proceed, and who owns the result. A deterministic protocol engine, implemented in conventional code rather than prompts, enforces those protocols by controlling stage transitions, requiring evidence, and invoking gates and human escalation, where needed, before work can advance. The SE Factory preserves human authority over consequential decisions and makes accountable acceptance possible without requiring humans to supervise every agent action. The SE Factory is not a dark factory. Humans remain in control by defining the scope and granularity of delegation, the boundaries and escalation conditions, and the consequential decisions that require accountable human judgment. We draw on our experience building three distinct SE Factory implementations, all of which have undergone multiple iterations and two of which are publicly available as open-source systems, into ten principles for conceiving, building, and operating SE Factories at scale, grounded in the organizational and technical realities of our implementations. We do not claim that these principles are exhaustive or constitute the only viable foundation for an SE Factory. Rather, we offer them as a conceptual scaffold and shared vocabulary for reasoning about SE Factories, evaluating their designs, and guiding their evolution. Our goal is to catalyze a community-wide dialogue that moves software engineering beyond controls designed for human-scale code production toward a disciplined, scalable, and trustworthy agentic future.

## 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.

## AI-Generated Code Security Risks: What Qodana Found in a Java App

DevFeed: [AI-Generated Code Security Risks: What Qodana Found in a Java App](<https://devfeed.tech/articles/ai-generated-code-security-risks-what-qodana-found-in-a-java-app-138462.md>)

Original publisher: [Read original article](<https://blog.jetbrains.com/qodana/2026/11/ai-generated-code-security-risks/>)

Author: Efim Samoylov

Published: 2026-11-17T11:33:51Z

Content type: article

Language: en

Sources: [JetBrains](<https://devfeed.tech/sources/the-jetbrains-blog.md>)

Topics: [code security](<https://devfeed.tech/topics/code-security.md>), [Static code analysis](<https://devfeed.tech/topics/static-code-analysis.md>), [software security audit](<https://devfeed.tech/topics/software-security-audit.md>), [software composition analysis](<https://devfeed.tech/topics/software-composition-analysis.md>), [alert triage](<https://devfeed.tech/topics/alert-triage.md>), [Code review](<https://devfeed.tech/topics/code-review.md>), [Code quality](<https://devfeed.tech/topics/code-quality.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>)

Tags: [ai-generated-code](<https://devfeed.tech/tags/ai-generated-code.md>), [ai-generated-code-security](<https://devfeed.tech/tags/ai-generated-code-security.md>), [java](<https://devfeed.tech/tags/java.md>), [qodana](<https://devfeed.tech/tags/qodana.md>), [security-vulnerabilities](<https://devfeed.tech/tags/security-vulnerabilities.md>), [static-analysis](<https://devfeed.tech/tags/static-analysis.md>)

### AI overview

In a deliberately vulnerable Java benchmark app, Qodana reported 65 findings across 21 files, a triage queue rather than a count of exploitable flaws. Examples show distinct review questions: a vulnerable XStream dependency and XML deserialization of a client-controlled cookie require checking whether deserialization is needed, restricting allowed types, and rejecting unexpected XML; a hardcoded fallback credential requires an external secret and startup failure if missing, though the inspection needed broader-than-default configuration to flag it; and a transitive LGPL dependency raises a project-policy and distribution question, not evidence of insecurity. Findings need application and deployment context, human review, and targeted tests. This single seeded-vulnerability case does not establish how often AI introduces vulnerabilities, and static analysis cannot determine every issue's exploitability or cover all runtime behavior.

### Source excerpt

Adding search functionality, converting a document, or connecting a service sound like small changes. An AI coding agent may take it on in one pass, changing application logic, dependencies, configuration, and tests along the way. The result may pass functional tests and still contain security vulnerabilities. Static analysis can surface some AI-generated code security risks, [...]

## 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

## 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.

## Code-Anchored Review Feedback Improves Correctness and Lowers Hosted Editing Cost on Large R Files

DevFeed: [Code-Anchored Review Feedback Improves Correctness and Lowers Hosted Editing Cost on Large R Files](<https://devfeed.tech/articles/code-anchored-review-feedback-improves-correctness-and-lowers-hosted-editing-cost-on-large-r-files-137929.md>)

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

Author: William Franz Lamberti

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>), [generative-ai-tools](<https://devfeed.tech/topics/generative-ai-tools.md>), [Code quality](<https://devfeed.tech/topics/code-quality.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-collaboration](<https://devfeed.tech/tags/ai-collaboration.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [base](<https://devfeed.tech/tags/base.md>), [changes](<https://devfeed.tech/tags/changes.md>), [channel](<https://devfeed.tech/tags/channel.md>), [claude](<https://devfeed.tech/tags/claude.md>), [claude-opus](<https://devfeed.tech/tags/claude-opus.md>), [claude-sonnet](<https://devfeed.tech/tags/claude-sonnet.md>), [code](<https://devfeed.tech/tags/code.md>), [code-review](<https://devfeed.tech/tags/code-review.md>), [collaboration](<https://devfeed.tech/tags/collaboration.md>), [cost](<https://devfeed.tech/tags/cost.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [feedback](<https://devfeed.tech/tags/feedback.md>), [files](<https://devfeed.tech/tags/files.md>), [hosted](<https://devfeed.tech/tags/hosted.md>), [large](<https://devfeed.tech/tags/large.md>), [r](<https://devfeed.tech/tags/r.md>), [review](<https://devfeed.tech/tags/review.md>)

### AI overview

In a paired experiment on 36 synthetic base-R tasks, code-anchored review feedback from FileMark improved correctness for four of five local models and reduced hosted editing costs for large files with Claude Opus and Sonnet. Compared with the same requested changes presented as a holistic list, the anchored format reduced output tokens by 14.7% for Opus and 50.5% for Sonnet; total tokens varied by model, from 4.2% fewer to 14.7% more. For files over 100 lines, hosted edit costs fell by 20.0% and 46.3%, respectively. The authors attribute correctness gains mainly to the format and quoted code, rather than wording. Misplaced anchors sharply reduced correctness, so the reported benefits depend on accurate anchors.

### Source excerpt

arXiv:2607.12713v2 Announce Type: replace Abstract: Tokens drive the cost and latency of generative AI (GAI) code editing, and correctness decides whether an edit is useful. We study how the format of a reviewer's feedback, a human-AI collaboration (HAIC) channel, impacts both. In a paired experiment on 36 synthetic base-R tasks with seven models, the same requested changes were delivered as a holistic list (control) or as the export of FileMark (treatment). That code-review extension anchors each comment to the code it concerns and quotes it. For the typical task, total tokens changed by -4.2% to +14.7% across models, while output tokens fell by 14.7% (Claude Opus) and 50.5\% (Claude Sonnet). Since an output token costs five times as much as an input token, the hosted cost of an edit on files over 100 lines fell by 20.0% (Opus) and 46.3% (Sonnet). The treatment raised the correct-run share of four of five local models by 24% to 46%. A decomposition experiment places these gains in the format, not the wording, and mostly in the quoted code. Misplaced anchors cut correctness sharply. Code-anchored feedback thus lowers hosted editing cost on large R files and makes weaker models more correct, provided the anchors are accurate.

## Use of Peer Code Review to Identify Potential Security Vulnerabilities in Open Source Software: A Systematic Literature Review

DevFeed: [Use of Peer Code Review to Identify Potential Security Vulnerabilities in Open Source Software: A Systematic Literature Review](<https://devfeed.tech/articles/use-of-peer-code-review-to-identify-potential-security-vulnerabilities-in-open-source-software-a-systematic-literature-review-137954.md>)

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

Author: Md Niaz Morshed, Jeffrey C. Carver

Published: 2026-11-17T05: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>), [code security](<https://devfeed.tech/topics/code-security.md>), [Vulnerabilities](<https://devfeed.tech/topics/vulnerabilities.md>), [Static code analysis](<https://devfeed.tech/topics/static-code-analysis.md>)

Tags: [code-review](<https://devfeed.tech/tags/code-review.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [open-source-software](<https://devfeed.tech/tags/open-source-software.md>), [sast-tools](<https://devfeed.tech/tags/sast-tools.md>), [security](<https://devfeed.tech/tags/security.md>)

### AI overview

A systematic review of 20 studies found that peer code review in open source software can catch localized, well-known vulnerabilities, such as buffer overruns, race conditions, crashes, and XSS, but often misses subtle, complex, context-dependent weaknesses involving input validation, access control, or resource lifecycles. Reviewer expertise, familiarity with the code, small frequent changes, and organizational support are associated with stronger detection. SAST tools can reduce reviewer effort and improve detection, but do not replace human judgment. The review identifies gaps in security knowledge, time, experience, and understanding of complex systems; it points to training, domain expertise, structured processes and checklists, supportive environments, organizational incentives, and lightweight tool support as ways to improve reviews. Peer review contributes to OSS security but is insufficient on its own.

### Source excerpt

arXiv:2611.18568v1 Announce Type: new Abstract: Context: Security vulnerabilities in OSS can have severe consequences. OSS project participants widely use peer code review to improve quality and prevent security flaws. However, despite mandatory reviews, OSS projects still contain vulnerabilities, highlighting the need to evaluate code review effectiveness for security. Objectives: This SLR synthesizes evidence on vulnerability types identified or missed, security practices, tool support, reviewer challenges, and factors that improve detection. Method: Searches of five digital libraries yielded 1,067 studies, of which 20 were included. Vulnerabilities were categorized using the Common Weakness Enumeration (CWE) framework. Results: Peer code reviews effectively detect localized, well-known vulnerabilities (e.g., buffer overruns, race conditions, crashes, XSS) but often miss subtle, complex, context-dependent issues (e.g., input validation weaknesses, access control weaknesses, resource lifecycle weaknesses). Effective security practices are associated with reviewer expertise, code familiarity, frequent small changes, and organizational support. Security analysis tools, especially Static Application Security Testing (SAST) tools, reduce reviewer effort and improve detection but cannot replace human judgment. Reviewers continue to face limitations in security knowledge, experience, time, and understanding of complex systems. Effectiveness improves through security training, domain expertise, contextual familiarity, formalized review processes, and supportive review environments. Conclusion: Peer code review contributes to OSS security but is insufficient on its own. Improving effectiveness requires structured review processes and checklists, security training, organizational incentives, and lightweight automated tool support to help reviewers detect subtle vulnerabilities while reinforcing secure development practices.

## Where AI Use Is Normalized, Author Seniority but Not AI Disclosure Biases Code Review

DevFeed: [Where AI Use Is Normalized, Author Seniority but Not AI Disclosure Biases Code Review](<https://devfeed.tech/articles/where-ai-use-is-normalized-author-seniority-but-not-ai-disclosure-biases-code-review-137958.md>)

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

Author: Jenna Butler, Emerson Murphy-Hill, Constance Hadley, Alexa Tipton, Nancy Baym, Sankeerti Haniyur, Jina Suh

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-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.md>), [engineering-culture](<https://devfeed.tech/topics/engineering-culture.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-disclosure](<https://devfeed.tech/tags/ai-disclosure.md>), [ai-use](<https://devfeed.tech/tags/ai-use.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [bias](<https://devfeed.tech/tags/bias.md>), [but](<https://devfeed.tech/tags/but.md>), [can](<https://devfeed.tech/tags/can.md>), [code](<https://devfeed.tech/tags/code.md>), [code-review](<https://devfeed.tech/tags/code-review.md>), [commit](<https://devfeed.tech/tags/commit.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [disclosure](<https://devfeed.tech/tags/disclosure.md>), [display](<https://devfeed.tech/tags/display.md>), [effectiveness](<https://devfeed.tech/tags/effectiveness.md>), [embedded](<https://devfeed.tech/tags/embedded.md>), [engineers](<https://devfeed.tech/tags/engineers.md>), [evaluations](<https://devfeed.tech/tags/evaluations.md>), [experiment](<https://devfeed.tech/tags/experiment.md>), [information](<https://devfeed.tech/tags/information.md>), [review](<https://devfeed.tech/tags/review.md>)

### AI overview

In a within-subjects experiment at an organization where AI use was normalized, 447 software engineers reviewed four code snippets with AI-use disclosure and author-seniority labels shown in commit messages. Disclosure did not bias perceived code effectiveness or author competence, while seniority labels significantly biased both. The result indicates no detected penalty for disclosed AI use in this setting; it does not establish that disclosure has no effect in other settings.

### Source excerpt

arXiv:2611.18572v1 Announce Type: new Abstract: Code-review tools increasingly display whether an author used AI when preparing pull requests. Recent studies report that AI disclosure makes reviewers rate otherwise identical work as less competent, with the penalty falling hardest on already-marginalized authors. In a within-subjects experiment in an AI-normalized organization, 447 software engineers each reviewed the same four code snippets under an AI-use disclosure embedded in the commit message and author-seniority labels. AI disclosure did not bias perceptions of code effectiveness or author competence, whereas a seniority label significantly biased both. Together, these findings show no detected penalty for disclosed AI use in this setting, while confirming that the author information shown in code review can still bias evaluations.

## 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.

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