# Static code analysis

Static code analysis is a software development practice that examines source code without executing it to identify bugs, security vulnerabilities, and coding-style 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.

## Forrester Recognizes Checkmarx in The Forrester Wave™: Agentic Development Security Tools, Q4 2026

DevFeed: [Forrester Recognizes Checkmarx in The Forrester Wave™: Agentic Development Security Tools, Q4 2026](<https://devfeed.tech/articles/forrester-recognizes-checkmarx-in-the-forrester-wavetm-agentic-development-security-tools-q4-2026-146870.md>)

Original publisher: [Read original article](<https://checkmarx.com/blog/checkmarx-forrester-wave-agentic-development-security-tools-q4-2026/>)

Author: Checkmarx Team

Published: 2026-11-20T17:03:20Z

Content type: article

Language: en

Sources: [Checkmarx](<https://devfeed.tech/sources/checkmarx.md>)

Topics: [code security](<https://devfeed.tech/topics/code-security.md>), [AI software supply chain security](<https://devfeed.tech/topics/ai-software-supply-chain-security.md>), [Static code analysis](<https://devfeed.tech/topics/static-code-analysis.md>), [AI-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.md>), [LLM security](<https://devfeed.tech/topics/llm-security.md>), [DevSecOps](<https://devfeed.tech/topics/devsecops.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [agent](<https://devfeed.tech/tags/agent.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [agentic-development](<https://devfeed.tech/tags/agentic-development.md>), [agentic-development-lifecycle](<https://devfeed.tech/tags/agentic-development-lifecycle.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-application](<https://devfeed.tech/tags/ai-application.md>), [ai-llm-tools-in-application-security](<https://devfeed.tech/tags/ai-llm-tools-in-application-security.md>), [analyst-reports](<https://devfeed.tech/tags/analyst-reports.md>), [application](<https://devfeed.tech/tags/application.md>), [aspm](<https://devfeed.tech/tags/aspm.md>), [autonomous](<https://devfeed.tech/tags/autonomous.md>), [blog](<https://devfeed.tech/tags/blog.md>), [checkmarx](<https://devfeed.tech/tags/checkmarx.md>), [code](<https://devfeed.tech/tags/code.md>), [development](<https://devfeed.tech/tags/development.md>), [forrester](<https://devfeed.tech/tags/forrester.md>), [forrester-wave](<https://devfeed.tech/tags/forrester-wave.md>), [q4](<https://devfeed.tech/tags/q4.md>), [remediation](<https://devfeed.tech/tags/remediation.md>), [security](<https://devfeed.tech/tags/security.md>), [security-tools](<https://devfeed.tech/tags/security-tools.md>), [tools](<https://devfeed.tech/tags/tools.md>)

### AI overview

Checkmarx says Forrester's Q4 2026 Agentic Development Security Tools evaluation gave it the highest possible scores for AI application flaws, autonomous proprietary code remediation, and ASPM for AI. The article frames agentic development security as a response to coding agents that generate code, choose dependencies, invoke tools, and execute tasks at machine speed. Checkmarx describes a three-part approach: combine rules-based and AI analysis, then consolidate findings and flag false positives; prevent issues through Developer Assist and prioritize existing findings by reachability, exploitability, business context, and compensating controls for guided-to-autonomous fixes; and correlate risk, assign owners, enforce policy gates, and deterministically govern models, MCP servers, and agents. It also says malicious and hallucinated packages are blocked in real time against a database of more than 550,000 known malicious packages. These are Checkmarx's descriptions of its capabilities; the text notes that Forrester does not endorse vendors or advise selection based on ratings.

### Source excerpt

Checkmarx received the highest score possible in the criteria of AI application flaws, autonomous proprietary code remediation, and ASPM for AI.

## Characterizing and Detecting Unfaithful Work Reports by Coding Agents

DevFeed: [Characterizing and Detecting Unfaithful Work Reports by Coding Agents](<https://devfeed.tech/articles/characterizing-and-detecting-unfaithful-work-reports-by-coding-agents-145584.md>)

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

Author: Wenhao Yang, Runzhi He, Minghui Zhou, Pengfei Gao, Dayi Lin, Qingwei Lin, Dongmei Zhang

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

Content type: article

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: [agentic-coding](<https://devfeed.tech/topics/agentic-coding.md>), [Multi-step AI processes](<https://devfeed.tech/topics/multi-step-ai-processes.md>), [Static code analysis](<https://devfeed.tech/topics/static-code-analysis.md>)

Tags: [agent-evaluation](<https://devfeed.tech/tags/agent-evaluation.md>), [analysis](<https://devfeed.tech/tags/analysis.md>), [automated](<https://devfeed.tech/tags/automated.md>), [coding](<https://devfeed.tech/tags/coding.md>), [coding-agents](<https://devfeed.tech/tags/coding-agents.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [development](<https://devfeed.tech/tags/development.md>), [reports](<https://devfeed.tech/tags/reports.md>)

### AI overview

The abstract identifies four categories of unfaithful coding-agent reports: misreported observations, misattributed evidence, overstated task success (the most common), and faulty technical explanations. In the analyzed cases, addressing these problems took an average of 4.3 additional user turns and 12.71 minutes of recorded response and execution time, and users more often expressed dissatisfaction. The authors also introduce FaithDetector, which scored about 13 percentage points above a baseline in macro-F1 on naturally sampled reports. The excerpt leaves the exact share of unfaithful reports and FaithDetector's exact macro-F1 unspecified.

### Source excerpt

arXiv:2611.25760v1 Announce Type: cross Abstract: Coding agents increasingly carry out long-horizon development tasks, autonomously planning and executing multi-step actions that span files, tools, and sessions. Because developers rarely follow each action, and agents resuming the work depend on records of what was done, the agent's work report often becomes the primary account of what was changed and established. When the report contains false or unsupported claims, it gives recipients false assurance: incomplete work may be accepted without verification, incorrect assumptions about the current state can propagate to later steps and agents, and evaluators that credit stated success may reward the report rather than the work. Yet little is known about what unfaithful reporting looks like in real development work, or how developers and agents handle it once it surfaces. Starting from real developer--agent conversations in SWE-chat, we conduct a systematic mixed-methods analysis of self-admitted unfaithful reports. We identify eleven subtypes in four categories: misreported observations, misattributed evidence, overstated task success, and faulty technical explanations, with overstated task success the most common. Handling these problems involves on average 4.3 further user turns and 12.71 minutes of recorded response and execution time, and users express dissatisfaction more often. Among 435 work reports that we separately sample and annotate, \NaturalPositiveShare{}\% contain at least one unfaithful claim. We also develop FaithDetector, a detector for unfaithful reporting informed by the observed patterns. On naturally sampled reports, FaithDetector attains \NaturalDetectorMacro{}\% macro-F1, about 13 percentage points above the baseline. Together, our findings and FaithDetector provide empirical evidence and an automated method for checking reporting faithfulness, informing agent evaluation and training feedback.

## Static Analysis Guidance for Secure LLM Code Generation

DevFeed: [Static Analysis Guidance for Secure LLM Code Generation](<https://devfeed.tech/articles/static-analysis-guidance-for-secure-llm-code-generation-145789.md>)

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

Author: Daniele Lunghi, Alberick Euraste Djir\\'e, Zacharie Chenail-Larcher, M\\'elissa Tessa, Quentin Sti\\'evenart, Jacques Klein, Florent Avellaneda, Naouel Moha, Tegawend\\'e'e F. Bissyand\\'e

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

Content type: article

Language: en

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

Topics: [Static code analysis](<https://devfeed.tech/topics/static-code-analysis.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [LLM security](<https://devfeed.tech/topics/llm-security.md>)

Tags: [alert](<https://devfeed.tech/tags/alert.md>), [alerts](<https://devfeed.tech/tags/alerts.md>), [analysis](<https://devfeed.tech/tags/analysis.md>), [analyzer](<https://devfeed.tech/tags/analyzer.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [code](<https://devfeed.tech/tags/code.md>), [code-generation](<https://devfeed.tech/tags/code-generation.md>), [comment](<https://devfeed.tech/tags/comment.md>), [control](<https://devfeed.tech/tags/control.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [deepseek](<https://devfeed.tech/tags/deepseek.md>), [deepseek-v4-1-flash](<https://devfeed.tech/tags/deepseek-v4-1-flash.md>), [error](<https://devfeed.tech/tags/error.md>), [feedback](<https://devfeed.tech/tags/feedback.md>), [functional](<https://devfeed.tech/tags/functional.md>), [generation](<https://devfeed.tech/tags/generation.md>), [guidance](<https://devfeed.tech/tags/guidance.md>), [llm](<https://devfeed.tech/tags/llm.md>), [static](<https://devfeed.tech/tags/static.md>), [static-analysis](<https://devfeed.tech/tags/static-analysis.md>)

### AI overview

The study finds that static analyzer feedback during generation can improve secure code generation at much lower token cost than iterative repair. It tests two strategies: rolling back generation after an alert and inserting the finding as a code comment (Comment) or into the user message (Steering). Across three models and Python benchmarks, these methods use 0.9-1.9 times baseline output tokens, versus up to 24.1 times for iterative approaches. On RiskyPy, DeepSeek-V4.1-flash with Steering raises the share of functional, secure programs from 52.5% to 64.4%, near the best iterative result of 66.2% for less than a fifth of the tokens. Benefits are strongest for rules with local fixes. Limits include sparse alerts on functional but insecure SecEvalPlus programs, failures when alerts conflict with the task, and Qwen2.5 models' difficulty with fixes requiring code restructuring. The reported results support filtering conflicting alerts and focusing guidance on local fixes with capable models.

### Source excerpt

arXiv:2611.26312v1 Announce Type: new Abstract: Static analyzers are cheap and widely deployed, which makes their reports a candidate feedback signal for secure LLM code generation. Existing approaches place the analyzer inside an iterative repair loop with intermediate steps, which is costly and makes it hard to isolate the report's effect on the model. We introduce two strategies that give the finding to the model during generation. When the analyzer raises an alert, generation is rolled back, and the finding is inserted either as a code comment (Comment) or in the user message (Steering). We compare them with two iterative approaches and a control without the analyzer, across three models and three Python benchmarks, and we measure security using each benchmark's oracle. Guidance during generation is cheap and can be effective, at 0.9 to 1.9 times the baseline's output tokens against up to 24.1 times for iterative approaches. With DeepSeek-V4.1-flash on RiskyPy, Steering raises the share of functional and secure programs from 52.5% to 64.4%, close to the best iterative approach (66.2%) while using less than a fifth of the tokens. A per-rule analysis shows that rules with a local fix benefit most, and replacing the XML parser is net-positive on two of the three models. The study also identifies when guidance should not be applied. Analyzers flag at most 5.6% of the functional but insecure programs on SecEvalPlus, leaving little guidance to act on. When a static analysis alert (warning or error) contradicts the task, models tend to follow the analyzer and break the program. The two Qwen2.5 models often fail when the fix requires restructuring the code. These results indicate that static-analysis guidance is worth applying with a capable model, on rules with a local fix, and after filtering alerts that conflict with the task specification.

## Automatic analysis for Bitbucket Cloud is now available

DevFeed: [Automatic analysis for Bitbucket Cloud is now available](<https://devfeed.tech/articles/automatic-analysis-for-bitbucket-cloud-is-now-available-146292.md>)

Original publisher: [Read original article](<https://www.sonarsource.com/blog/automatic-analysis-for-bitbucket-cloud-is-now-available/>)

Author: Robert Curlee

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

Content type: release

Language: en

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

Topics: [Static code analysis](<https://devfeed.tech/topics/static-code-analysis.md>), [bitbucket](<https://devfeed.tech/topics/bitbucket.md>)

Tags: [advanced](<https://devfeed.tech/tags/advanced.md>), [automatic-analysis](<https://devfeed.tech/tags/automatic-analysis.md>), [bitbucket](<https://devfeed.tech/tags/bitbucket.md>), [bugs](<https://devfeed.tech/tags/bugs.md>), [c-sharp](<https://devfeed.tech/tags/c-sharp.md>), [ci-pipeline](<https://devfeed.tech/tags/ci-pipeline.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [code](<https://devfeed.tech/tags/code.md>), [code-health](<https://devfeed.tech/tags/code-health.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [critical](<https://devfeed.tech/tags/critical.md>), [feature](<https://devfeed.tech/tags/feature.md>), [feedback](<https://devfeed.tech/tags/feedback.md>), [frictionless](<https://devfeed.tech/tags/frictionless.md>), [pipeline](<https://devfeed.tech/tags/pipeline.md>), [security](<https://devfeed.tech/tags/security.md>), [sonarqube](<https://devfeed.tech/tags/sonarqube.md>), [sonarqube-cloud](<https://devfeed.tech/tags/sonarqube-cloud.md>), [zero](<https://devfeed.tech/tags/zero.md>), [zero-configuration](<https://devfeed.tech/tags/zero-configuration.md>)

### AI overview

SonarQube Cloud automatic analysis for Bitbucket Cloud scans repository code without CI pipeline setup or YAML edits. The excerpt says it detects security issues and bugs across more than 20 languages, including JavaScript, TypeScript, Python, Java, and C#. It presents the feature as a way to get quick visibility into code health, while noting that CI-driven analysis remains the standard for advanced production workflows.

### Source excerpt

SonarQube Cloud automatic analysis for Bitbucket Cloud scans code for security issues and bugs with zero configuration and no CI pipeline setup required.

## JITAtlas: Checking Lifetime and Protection Obligations in Compiler Rewrites

DevFeed: [JITAtlas: Checking Lifetime and Protection Obligations in Compiler Rewrites](<https://devfeed.tech/articles/jitatlas-checking-lifetime-and-protection-obligations-in-compiler-rewrites-142193.md>)

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

Author: Baihong Chen (Utah State University), Wen Li (Utah State University)

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

Content type: article

Language: en

Sources: [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: [Static code analysis](<https://devfeed.tech/topics/static-code-analysis.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>)

Tags: [bugs](<https://devfeed.tech/tags/bugs.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [lifetime](<https://devfeed.tech/tags/lifetime.md>), [ownership](<https://devfeed.tech/tags/ownership.md>), [protection](<https://devfeed.tech/tags/protection.md>)

### AI overview

JITAtlas checks whether compiler rewrites preserve valid object use, continuous support for borrowed pointers, and caller-visible ownership, even when returned values remain unchanged. It reconstructs reference and target computations from optimizer code. On an independently constructed 58-input benchmark, it detected all 29 defects and reported none of 29 safe cases; PyRefcon detected 20 defects and CpyChecker 18. Across three CPython snapshots, it retained 801 of 3,332 extracted rewrite alternatives in recovered receiving contexts and reported 194 violations. Manual review confirmed 92 reports (47.42% precision); analysis took 35.56-42.31 seconds per snapshot. The study also reports 15 new bugs across five failure classes, each with a reproducible proof of concept.

### Source excerpt

arXiv:2611.23715v1 Announce Type: cross Abstract: Compiler rewrites can preserve returned values while violating object lifetime or ownership. Such failures arise when a rewrite changes when an object remains live, whether a borrowed pointer stays supported, or what ownership reaches the caller. We present JITAtlas, a source-level checker that reconstructs reference and target computations from optimizer code and checks valid uses, continuous borrow support, and caller-visible ownership. On a 58-input benchmark constructed and labeled independently of JITAtlas output, JITAtlas detects all 29 defects and reports none of 29 safe inputs; PyRefcon detects 20 defects and CpyChecker 18. Across three CPython snapshots, JITAtlas extracts 3,332 rewrite alternatives, retains 801 under recovered receiving contexts, and reports 194 violations. Manual review confirms 92 reports, giving 47.42% precision. End-to-end analysis takes 35.56-42.31 s per snapshot. JITAtlas further identifies 15 new bugs across five failure classes, each with a reproducible proof of concept.

## Characterizing GitHub Security Actions Alerts For Web Application Tutorials

DevFeed: [Characterizing GitHub Security Actions Alerts For Web Application Tutorials](<https://devfeed.tech/articles/characterizing-github-security-actions-alerts-for-web-application-tutorials-142203.md>)

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

Author: Bhagya Chembakottu, Martin P. Robillard

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

Content type: article

Language: en

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

Topics: [Static code analysis](<https://devfeed.tech/topics/static-code-analysis.md>), [Application Security](<https://devfeed.tech/topics/application-security.md>), [GitHub](<https://devfeed.tech/topics/github.md>), [Learning](<https://devfeed.tech/topics/learning.md>), [alert triage](<https://devfeed.tech/topics/alert-triage.md>), [Django](<https://devfeed.tech/topics/django.md>), [Spring Framework](<https://devfeed.tech/topics/spring-framework.md>), [Web Development](<https://devfeed.tech/topics/web-development.md>)

Tags: [actions](<https://devfeed.tech/tags/actions.md>), [alert](<https://devfeed.tech/tags/alert.md>), [alerts](<https://devfeed.tech/tags/alerts.md>), [application](<https://devfeed.tech/tags/application.md>), [application-development](<https://devfeed.tech/tags/application-development.md>), [application-security](<https://devfeed.tech/tags/application-security.md>), [application-security-testing](<https://devfeed.tech/tags/application-security-testing.md>), [applications](<https://devfeed.tech/tags/applications.md>), [code](<https://devfeed.tech/tags/code.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [cybersecurity](<https://devfeed.tech/tags/cybersecurity.md>), [developers](<https://devfeed.tech/tags/developers.md>), [development](<https://devfeed.tech/tags/development.md>), [development-practices](<https://devfeed.tech/tags/development-practices.md>), [django](<https://devfeed.tech/tags/django.md>), [github](<https://devfeed.tech/tags/github.md>), [github-security](<https://devfeed.tech/tags/github-security.md>), [security](<https://devfeed.tech/tags/security.md>), [tutorials](<https://devfeed.tech/tags/tutorials.md>), [web](<https://devfeed.tech/tags/web.md>)

### AI overview

An analysis of 6,609 alerts from four default GitHub Security Actions configurations across 60 Django and Spring tutorial repositories found that alerts do not consistently target tutorial code or give specific remediation guidance. Of the alerts, 56.7% targeted tutorial-related files and 43.3% other repository files. Configurations triggered 34-646 distinct rules, with their five most frequent rules accounting for 25.2%-68.2% of alerts. Depending on configuration, 0.4%-32.1% of messages named concrete framework or code constructs, and 0%-8.1% met the study's criteria for remediation specificity. The study assessed alert volume, relevance, conceptual breadth, and remediation usability.

### Source excerpt

arXiv:2611.23967v1 Announce Type: new Abstract: The high frequency of cybersecurity incidents involving web applications highlights the importance of secure software development practices. Static Application Security Testing (SAST) tools help identify potential vulnerabilities in source code without executing the code. Integrating SAST tools into GitHub Security Actions enables security alerts to be reported during development. However, the characteristics of these alerts can make them difficult for developers with limited security expertise to understand, prioritize, and address. Many tutorials for learning web application development also involve source code with security implications. We investigated the properties of SAST alerts relevant to this learning context. We analyzed 6,609 alerts from four default GitHub Security Actions configurations across 60 Django and Spring tutorial repositories. We evaluated the alerts along four dimensions: alert volume, alert relevance, conceptual breadth, and remediation usability. Of the 6,609 alerts, 3,750 (56.7\%) targeted tutorial-related files, while 2,859 (43.3\%) targeted other repository files. The configurations triggered between 34 and 646 distinct rules, and the five most frequently triggered rules accounted for 25.2\%--68.2\% of alerts, depending on the configuration. Across configurations, 0.4\%--32.1\% of alert messages named concrete framework or code constructs, and 0\%--8.1\% met our operational criteria for remediation specificity. Overall, default GitHub Security Actions report a diverse set of security alerts, but these alerts do not consistently focus on tutorial code or provide concrete guidance for addressing the reported issues.

## Metrics-in-the-Loop: Complexity Feedback Reshapes Agent-Written Code

DevFeed: [Metrics-in-the-Loop: Complexity Feedback Reshapes Agent-Written Code](<https://devfeed.tech/articles/metrics-in-the-loop-complexity-feedback-reshapes-agent-written-code-142704.md>)

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

Author: Nicolas Chapados, Jean-Fran\\c{c}ois Gagn\\'e, Nouha Dziri

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

Content type: article

Language: en

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

Topics: [AI-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.md>), [Code quality](<https://devfeed.tech/topics/code-quality.md>), [Static code analysis](<https://devfeed.tech/topics/static-code-analysis.md>), [reliable codebases](<https://devfeed.tech/topics/reliable-codebases.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [code](<https://devfeed.tech/tags/code.md>), [coding-agents](<https://devfeed.tech/tags/coding-agents.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [coverage](<https://devfeed.tech/tags/coverage.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cyclomatic-complexity](<https://devfeed.tech/tags/cyclomatic-complexity.md>), [experiments](<https://devfeed.tech/tags/experiments.md>), [feedback](<https://devfeed.tech/tags/feedback.md>), [in-the-loop](<https://devfeed.tech/tags/in-the-loop.md>), [maintainability](<https://devfeed.tech/tags/maintainability.md>), [measurements](<https://devfeed.tech/tags/measurements.md>), [metrics](<https://devfeed.tech/tags/metrics.md>), [models](<https://devfeed.tech/tags/models.md>), [refactor](<https://devfeed.tech/tags/refactor.md>), [test](<https://devfeed.tech/tags/test.md>), [test-coverage](<https://devfeed.tech/tags/test-coverage.md>), [tests](<https://devfeed.tech/tags/tests.md>), [with](<https://devfeed.tech/tags/with.md>)

### AI overview

Metrics-in-the-loop gives coding agents feedback during long autonomous runs by injecting automatically computed metrics after each code-changing turn. Messages flag changed functions above a cyclomatic-complexity limit or changed lines skipped by tests, allowing agents to refactor or strengthen tests before continuing. Across three long-horizon coding benchmarks and four models, complexity feedback significantly reduced erosion--a measure of complexity concentration--without affecting held-out correctness. The supplied abstract describes coverage feedback as part of the intervention but does not report its comparative results.

### Source excerpt

arXiv:2611.23817v1 Announce Type: new Abstract: Coding agents now write whole codebases in long autonomous runs, guided mainly by whether their tests pass. Yet passing tests alone does not reveal accumulating complexity or gaps in test coverage, which then persist as agents extend their own code. We introduce metrics-in-the-loop, an inference-time intervention that gives agents in-flight feedback: cheap, automatically computed code metrics injected into the agent's context during the trajectory. After each code-changing agent turn, we insert short feedback messages naming changed functions whose cyclomatic complexity exceeds a limit (complexity feedback) or changed lines that are skipped by tests (coverage feedback), giving the agent the opportunity to refactor code or strengthen tests before continuing. We run extensive experiments and ablations comparing several interventions across three long-horizon coding benchmarks and four strong models. We find that complexity feedback significantly reduces erosion, a measure of complexity concentration of code, without affecting held-out correctness of the code. Broadly, our experiments investigate a practical form of agent "re-railing", where timely, actionable measurements redirect agents before weaknesses become the foundation they keep building on. As agents scale to codebases with millions of lines, such interventions become critical to sustaining effective development and long-term code maintainability.

## ACaM: Automated Capability Modeling for Agentic AI Security

DevFeed: [ACaM: Automated Capability Modeling for Agentic AI Security](<https://devfeed.tech/articles/acam-automated-capability-modeling-for-agentic-ai-security-143124.md>)

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

Author: Monika Santra, Dhilung Kirat, Qiushi Wu, Kevin Eykholt, Xiaokui Shu, Ian Molloy

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

Content type: article

Language: en

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

Topics: [ai security](<https://devfeed.tech/topics/ai-security.md>), [Static code analysis](<https://devfeed.tech/topics/static-code-analysis.md>), [Agentic AI](<https://devfeed.tech/topics/what-is-agentic-ai.md>), [Multi Agent Systems](<https://devfeed.tech/topics/multi-agent-systems.md>), [AI software supply chain security](<https://devfeed.tech/topics/ai-software-supply-chain-security.md>), [code security](<https://devfeed.tech/topics/code-security.md>)

Tags: [agentic](<https://devfeed.tech/tags/agentic.md>), [agentic-ai](<https://devfeed.tech/tags/agentic-ai.md>), [agentic-ai-security](<https://devfeed.tech/tags/agentic-ai-security.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-security](<https://devfeed.tech/tags/ai-security.md>), [analysis](<https://devfeed.tech/tags/analysis.md>), [automated](<https://devfeed.tech/tags/automated.md>), [capabilities](<https://devfeed.tech/tags/capabilities.md>), [capability](<https://devfeed.tech/tags/capability.md>), [code](<https://devfeed.tech/tags/code.md>), [compromise](<https://devfeed.tech/tags/compromise.md>), [credentials](<https://devfeed.tech/tags/credentials.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [data](<https://devfeed.tech/tags/data.md>), [dci](<https://devfeed.tech/tags/dci.md>), [drift](<https://devfeed.tech/tags/drift.md>), [exploits](<https://devfeed.tech/tags/exploits.md>), [external](<https://devfeed.tech/tags/external.md>), [external-services](<https://devfeed.tech/tags/external-services.md>), [modeling](<https://devfeed.tech/tags/modeling.md>), [security](<https://devfeed.tech/tags/security.md>)

### AI overview

ACaM models what agent tools can access and do from their code, addressing description-code inconsistency that can conceal dangerous capabilities behind benign tool descriptions. Static analysis establishes code-derived facts that the LLM cannot override; the LLM supplies behavioral meaning those facts cannot capture. ACaM compiles agent source into an Agent Capability Property Graph to reconstruct threat chains across tool calls. In tests on 24 manually annotated agents, it recovered capability properties at 98.3% macro-F1 and scored 0.980 on injected threat-chain reconstruction, 8 points above the strongest baseline. Across 43 real-world agents, including 9 multi-agent systems, it found hundreds of structural vulnerabilities; 10 were confirmed with proof-of-concept exploits.

### Source excerpt

arXiv:2611.23507v1 Announce Type: new Abstract: In agentic AI systems, an LLM invokes tools that hold standing access to credentials, private data, filesystems, and external services. Such agents are increasingly deployed without an answer to a basic question: what can an agent access, exfiltrate, and propagate, independent of what it is designed for or is observed to do? The question goes unanswered because existing approaches trust a tool's natural-language description as a proxy for its behavior. But nothing enforces that the description and its implementation agree. This gap is known as Description-Code Inconsistency (DCI). DCI enables a threat class called capability laundering, in which a tool's implementation contains dangerous behavior that its description omits. The behavior may come from incidental drift or a supply-chain compromise. It runs silently whenever an LLM invokes the tool for its stated, benign purpose. We present ACaM, a neurosymbolic approach to capability modeling that derives each tool's capabilities from its code, so a laundered capability cannot hide behind a benign description. In ACaM, static analysis grounds an LLM in code-derived facts, and no LLM output can override a fact that static analysis has established. The LLM supplies only the behavioral meaning that those facts cannot express. ACaM compiles agent source code into the Agent Capability Property Graph (ACPG) and uses it to reconstruct threat chains that span multiple tool calls. We evaluate ACaM on 43 real-world agents, including 9 multi-agent systems. On 24 manually annotated agents, it recovers capability properties with 98.3% macro-F1 and reconstructs injected threat chains with a score of 0.980, 8 points above the strongest baseline. Applied to all 43 unmodified agents, it discovers hundreds of structural vulnerabilities, ten of which we confirm with proof-of-concept exploits.

## Why the Harness Matters: Early Lessons From the Evo Code Scanning Agent Preview

DevFeed: [Why the Harness Matters: Early Lessons From the Evo Code Scanning Agent Preview](<https://devfeed.tech/articles/why-the-harness-matters-early-lessons-from-the-evo-code-scanning-agent-preview-146509.md>)

Original publisher: [Read original article](<https://snyk.io/blog/why-harness-matters-evo-code-scanning-agent/>)

Author: Brian Clark; Adrian Meier; Pauline Bolignano

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

Content type: news

Language: en

Sources: [Snyk](<https://devfeed.tech/sources/blog-rss-feed-snyk.md>)

Topics: [code security](<https://devfeed.tech/topics/code-security.md>), [Agent Harness](<https://devfeed.tech/topics/agent-harness.md>), [Static code analysis](<https://devfeed.tech/topics/static-code-analysis.md>), [AI Agent](<https://devfeed.tech/topics/ai-agent.md>), [LLM security](<https://devfeed.tech/topics/llm-security.md>), [Security](<https://devfeed.tech/topics/security.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [adoption](<https://devfeed.tech/tags/adoption.md>), [agent](<https://devfeed.tech/tags/agent.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-harness](<https://devfeed.tech/tags/ai-harness.md>), [ai-model](<https://devfeed.tech/tags/ai-model.md>), [ai-reasoning](<https://devfeed.tech/tags/ai-reasoning.md>), [ai-security-agents](<https://devfeed.tech/tags/ai-security-agents.md>), [blog](<https://devfeed.tech/tags/blog.md>), [budget](<https://devfeed.tech/tags/budget.md>), [claude](<https://devfeed.tech/tags/claude.md>), [code](<https://devfeed.tech/tags/code.md>), [code-scanning](<https://devfeed.tech/tags/code-scanning.md>), [code-security](<https://devfeed.tech/tags/code-security.md>), [codex](<https://devfeed.tech/tags/codex.md>), [compute](<https://devfeed.tech/tags/compute.md>), [developer](<https://devfeed.tech/tags/developer.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [harness](<https://devfeed.tech/tags/harness.md>), [interest](<https://devfeed.tech/tags/interest.md>), [precision](<https://devfeed.tech/tags/precision.md>), [preview](<https://devfeed.tech/tags/preview.md>), [security](<https://devfeed.tech/tags/security.md>), [security-labs](<https://devfeed.tech/tags/security-labs.md>), [snyk-code](<https://devfeed.tech/tags/snyk-code.md>), [tests](<https://devfeed.tech/tags/tests.md>), [vulnerabilities](<https://devfeed.tech/tags/vulnerabilities.md>), [vulnerability-insights](<https://devfeed.tech/tags/vulnerability-insights.md>)

### AI overview

At equal compute, Evo Code Scanning Agent's security harness found a larger share of known vulnerabilities than either same-model lab tool across 14 applications: 57% versus Claude Security's 32% on Claude Sonnet 5.5, and 66% versus Codex Security deep's 43% on GPT-6.1 Sol. Precision was lower: 65% versus 94% for Claude and 90% versus 97.5% for Codex. Each lab tool also found some vulnerabilities Evo missed. Since each pair used the same model, the article attributes differences to the surrounding harness--how it plans work, divides code, investigates candidates, and selects findings. Results are early and based on Snyk's internal benchmark of 1,426 known vulnerabilities; Evo is still in experimental preview, and no tool found them all. The authors recommend treating AI scanners as one layer alongside SAST, SCA, and code review.

### Source excerpt

In early tests, Evo Code Scanning Agent's security harness found more known vulnerabilities than Claude Security and Codex Security at the same compute budget, with lower precision. See what the results reveal about the role of the harness in AI code scanning.

## Cut your vulnerability backlog with agentic remediation

DevFeed: [Cut your vulnerability backlog with agentic remediation](<https://devfeed.tech/articles/cut-your-vulnerability-backlog-with-agentic-remediation-144776.md>)

Original publisher: [Read original article](<https://about.gitlab.com/blog/gitlab-agentic-remediation/>)

Author: Mark Settle

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

Content type: release

Language: en

Sources: [GitLab](<https://devfeed.tech/sources/gitlab.md>)

Topics: [Agentic SOC](<https://devfeed.tech/topics/agentic-soc.md>), [Static code analysis](<https://devfeed.tech/topics/static-code-analysis.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>), [Test automation](<https://devfeed.tech/topics/test-automation.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [agentic-remediation](<https://devfeed.tech/tags/agentic-remediation.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-reasoning](<https://devfeed.tech/tags/ai-reasoning.md>), [api](<https://devfeed.tech/tags/api.md>), [application-security](<https://devfeed.tech/tags/application-security.md>), [application-security-testing](<https://devfeed.tech/tags/application-security-testing.md>), [backlog](<https://devfeed.tech/tags/backlog.md>), [blast-radius](<https://devfeed.tech/tags/blast-radius.md>), [bugs](<https://devfeed.tech/tags/bugs.md>), [code](<https://devfeed.tech/tags/code.md>), [code-execution](<https://devfeed.tech/tags/code-execution.md>), [context](<https://devfeed.tech/tags/context.md>), [cves](<https://devfeed.tech/tags/cves.md>), [developer](<https://devfeed.tech/tags/developer.md>), [discovery](<https://devfeed.tech/tags/discovery.md>), [duo](<https://devfeed.tech/tags/duo.md>), [features](<https://devfeed.tech/tags/features.md>), [product](<https://devfeed.tech/tags/product.md>), [remediation](<https://devfeed.tech/tags/remediation.md>), [security](<https://devfeed.tech/tags/security.md>), [vulnerability](<https://devfeed.tech/tags/vulnerability.md>)

### AI overview

GitLab 19.6 adds tools to scale vulnerability triage and remediation while keeping fixes under normal developer review and approval. Security managers can apply automated triage and remediation (ATR) profiles across projects by group or attribute, choosing Conservative, Standard, or Proactive settings for severity and automatic versus on-demand flows; ATR profiles require GitLab Ultimate. Vulnerability Context Flow, in beta for Ultimate, adds SAST risk context such as authentication requirements, sensitive-data handling, and exposure to untrusted input. A security dashboard MTTR chart tracks weekly fixes across first-party code and dependencies, with project, severity, and scan-type filters; it excludes dismissed findings and counts only vulnerabilities detected in the prior 90 days. Business Logic Security Analyzer is in beta: Ultimate customers can enable it themselves on GitLab.com, while Self-Managed and Dedicated customers must contact GitLab for access. Agents can propose fixes and rerun tests and scans, but developers review changes and existing approvals still apply.

### Source excerpt

Vulnerability backlogs are growing faster than teams can clear them. AI writes more code and finds more flaws, while fixes still move at human speed. NIST's National Vulnerability Database has already published twice as many CVEs in 2026 as in all of 2025, and ceased enriching most CVEs this past April. Compounding the problem, a finding that looks safe to defer may not stay that way. Attackers now use AI to find and exploit flaws in hours, even those long written off as theoretical. In October, frontier models uncovered PHP2Shell, a pair of unauthenticated remote code execution bugs in PHP that had been dismissed as unexploitable in 2012. Discovery and exploitation now run at machine speed. To keep up, defenders need agentic security tools that detect and remediate vulnerabilities with minimal manual effort while leaving teams in full control. GitLab 19.6 helps teams shrink their security findings backlog. Security managers can now turn on agentic triage and remediation across entire groups of projects without scripting against the API. A new agentic flow adds exploitability context to static application security testing (SAST) findings, so teams can prioritize the ones that pose real risk. Security leaders can then track the results on a new mean time to remediation (MTTR) chart. Find and fix faster with agentic security GitLab 19.6 builds on a platform that finds and fixes vulnerabilities with agentic security. GitLab Duo security agents use frontier AI reasoning to examine your codebase and every merge request for the logic flaws scanners miss, while built-in scanners catch known vulnerabilities from source to runtime. Agents filter out false positives before they reach a developer's queue, then help teams prioritize the rest by severity, exploitability, reachability, and blast radius. GitLab Orbit, our native knowledge graph, grounds that reasoning in the live state of your system. For confirmed findings, an agent writes a fix, opens a merge request, and trigge

## Why verification, not generation, is your secret to AI coding ROI

DevFeed: [Why verification, not generation, is your secret to AI coding ROI](<https://devfeed.tech/articles/why-verification-not-generation-is-your-secret-to-ai-coding-roi-140640.md>)

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

Author: Anirban Chatterjee

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

Content type: article

Language: en

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

Topics: [agentic-coding](<https://devfeed.tech/topics/agentic-coding.md>), [coding assistant](<https://devfeed.tech/topics/coding-assistant.md>), [Static code analysis](<https://devfeed.tech/topics/static-code-analysis.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-code](<https://devfeed.tech/tags/ai-code.md>), [ai-coding](<https://devfeed.tech/tags/ai-coding.md>), [ai-engineering](<https://devfeed.tech/tags/ai-engineering.md>), [autonomy](<https://devfeed.tech/tags/autonomy.md>), [code-generation](<https://devfeed.tech/tags/code-generation.md>), [coding-agents](<https://devfeed.tech/tags/coding-agents.md>), [confidence](<https://devfeed.tech/tags/confidence.md>), [post-contributed](<https://devfeed.tech/tags/post-contributed.md>), [roi](<https://devfeed.tech/tags/roi.md>), [software-development](<https://devfeed.tech/tags/software-development.md>), [sonarsource](<https://devfeed.tech/tags/sonarsource.md>), [sponsor-sonarsource](<https://devfeed.tech/tags/sponsor-sonarsource.md>), [sponsored-post-contributed](<https://devfeed.tech/tags/sponsored-post-contributed.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

The survey excerpt identifies verification as the constraint on AI coding gains: 76% of respondents say they cannot verify code as fast as AI generates it, 94% do not fully trust its functional correctness, and only 39% always check it before committing. The article reports mixed effects on reliability and security, alongside concerns about duplicated or hard-to-maintain code and AI-assisted attacks. To prepare for more autonomous agent workflows, it recommends defining requirements and quality criteria before work begins, governing agents with standards and permission limits, independently checking changes during development and before release, and retaining evidence of checks and fixes. It reports that teams using automated review as code is written more often report positive security impacts (61% versus 46%), and that strong verification tools increase trust for 77% of respondents. The excerpt notes that many organizations lack distinct or automated AI controls.

### Source excerpt

For two years, the question around AI coding was whether agents could write good code. Developers have largely answered it: The post Why verification, not generation, is your secret to AI coding ROI appeared first on The New Stack.

## From Flashlight to Floodlight: What Six Months of Frontier AI Has Changed at Cisco

DevFeed: [From Flashlight to Floodlight: What Six Months of Frontier AI Has Changed at Cisco](<https://devfeed.tech/articles/from-flashlight-to-floodlight-what-six-months-of-frontier-ai-has-changed-at-cisco-140281.md>)

Original publisher: [Read original article](<https://blogs.cisco.com/news/from-flashlight-to-floodlight-what-six-months-of-frontier-ai-has-changed-at-cisco>)

Author: Anthony Grieco

Published: 2026-11-18T10:00:21Z

Content type: article

Language: en

Sources: [Cisco Blogs](<https://devfeed.tech/sources/cisco-blogs.md>)

Topics: [Frontier AI](<https://devfeed.tech/topics/frontier-ai.md>), [code security](<https://devfeed.tech/topics/code-security.md>), [Security](<https://devfeed.tech/topics/security.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Static code analysis](<https://devfeed.tech/topics/static-code-analysis.md>), [Cisco](<https://devfeed.tech/topics/cisco.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [accountability](<https://devfeed.tech/tags/accountability.md>), [adversarial](<https://devfeed.tech/tags/adversarial.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-assisted](<https://devfeed.tech/tags/ai-assisted.md>), [ai-cybersecurity](<https://devfeed.tech/tags/ai-cybersecurity.md>), [ai-security](<https://devfeed.tech/tags/ai-security.md>), [artificial-intelligence-ai](<https://devfeed.tech/tags/artificial-intelligence-ai.md>), [assessment](<https://devfeed.tech/tags/assessment.md>), [assets](<https://devfeed.tech/tags/assets.md>), [automated](<https://devfeed.tech/tags/automated.md>), [automated-testing](<https://devfeed.tech/tags/automated-testing.md>), [automation](<https://devfeed.tech/tags/automation.md>), [build](<https://devfeed.tech/tags/build.md>), [cisco](<https://devfeed.tech/tags/cisco.md>), [cisco-ai-defense](<https://devfeed.tech/tags/cisco-ai-defense.md>), [code](<https://devfeed.tech/tags/code.md>), [executive-platform](<https://devfeed.tech/tags/executive-platform.md>), [flashlight](<https://devfeed.tech/tags/flashlight.md>), [frontier-ai](<https://devfeed.tech/tags/frontier-ai.md>), [mitigations](<https://devfeed.tech/tags/mitigations.md>), [scan](<https://devfeed.tech/tags/scan.md>), [security](<https://devfeed.tech/tags/security.md>), [security-fixes](<https://devfeed.tech/tags/security-fixes.md>), [shift](<https://devfeed.tech/tags/shift.md>), [threat-detection](<https://devfeed.tech/tags/threat-detection.md>)

### AI overview

Cisco reports that in six months, more than 50 specialized engineers used frontier AI and human validation to scan over 6.7 billion lines of code across its portfolio, while roughly 1,500 engineers delivered nearly 4,000 fixes in 2026 hardening releases. The company describes a shift from manually inspecting selected components to continuous automated assessment using agents for static analysis, live testing, configuration reviews, and exploit simulations. Engineers validate findings and fixes; Cisco says this visibility helps address defect classes and supports scheduled, grouped releases. It asks customers to move to hardened releases and says it is simplifying patching. Cisco also expects nearly 70% of its code to be AI-assisted by next year, with automated behavior testing and human accountability for new code. It presents the fixes as an initial effort, with ongoing assessments and security-by-design work still ahead.

### Source excerpt

Cisco uses frontier AI to scan 6.7B lines of code, resulting in 4,000 security fixes. It's a fundamental shift in how we find, fix, and build.

## Identifying and Repairing Energy Smells with Agent Skills

DevFeed: [Identifying and Repairing Energy Smells with Agent Skills](<https://devfeed.tech/articles/identifying-and-repairing-energy-smells-with-agent-skills-139619.md>)

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

Author: Mohammadjavad Mehditabar, Saurabhsingh Rajput, Tushar Sharma

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

Content type: article

Language: en

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

Topics: [Green Software](<https://devfeed.tech/topics/green-software.md>), [Agent Skills](<https://devfeed.tech/topics/agent-skills.md>), [Static code analysis](<https://devfeed.tech/topics/static-code-analysis.md>)

Tags: [agent-skills](<https://devfeed.tech/tags/agent-skills.md>), [computer-science](<https://devfeed.tech/tags/computer-science.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [energy](<https://devfeed.tech/tags/energy.md>), [energy-efficiency](<https://devfeed.tech/tags/energy-efficiency.md>), [python](<https://devfeed.tech/tags/python.md>)

### AI overview

DR. GREENS brings energy-smell checks into Python developers' coding environment, pairing a taxonomy of 12 smells and 65 root causes with repair guidance from 230 measured cases. It combines a static analyzer with an independent verifier to check that attempted repairs preserve behavior and save energy. Across 18 sessions on three open-source repositories, using two models and three configurations, 68.6% of 258 measured repairs saved energy, with a median saving of 24.9%. The full skill found more energy smells with verified savings than a baseline without the taxonomy across all three repositories and both models. These results are limited to the reported evaluation.

### Source excerpt

arXiv:2611.23203v1 Announce Type: new Abstract: Energy smells are inefficient implementations that waste energy. Once code reaches production, these smells become costlier and riskier to fix, so energy efficiency checks should shift left, i.e., move earlier in the development lifecycle, to where code is written. Existing energy smell tools rely on fixed static rules and do not measure energy savings, whereas LLM-based optimizers mostly target execution time and rarely ground their changes in concrete smell definitions. To address both limitations, we present DR. GREENS, an agent skill that detects and repairs energy smells in Python code within the developer's coding environment. The skill grounds the coding agent in our taxonomy of 12 energy smells and 65 root causes, augmented with repair guidance drawn from 230 measured cases. The skill also encapsulates a static analyzer and an independent verifier to confirm behavior preservation and energy saving for each attempted repair. We evaluated DR. GREENS in 18 sessions on three open-source repositories, with two models and three skill configurations. Of the 258 measured repairs, 68.6% saved energy, with a median saving of 24.9%. Compared with a baseline skill that lacks the taxonomy, the full skill found more energy smells with verified savings in all three repositories with both models. DR. GREENS helps developers detect energy hotspots and fix them reliably without altering program behavior, which makes energy-efficient development more feasible.

## On Improving the Adoption, Usability, and Retention of Static Application Security Testing (SAST) Tools

DevFeed: [On Improving the Adoption, Usability, and Retention of Static Application Security Testing (SAST) Tools](<https://devfeed.tech/articles/on-improving-the-adoption-usability-and-retention-of-static-application-security-testing-sast-tools-139581.md>)

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

Author: Zachary Douglas Wadhams

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

Content type: article

Language: en

Sources: [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: [Static code analysis](<https://devfeed.tech/topics/static-code-analysis.md>), [Application Security](<https://devfeed.tech/topics/application-security.md>), [Developer Enablement](<https://devfeed.tech/topics/developer-enablement.md>), [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>)

Tags: [adoption](<https://devfeed.tech/tags/adoption.md>), [application](<https://devfeed.tech/tags/application.md>), [application-security](<https://devfeed.tech/tags/application-security.md>), [application-security-testing](<https://devfeed.tech/tags/application-security-testing.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [false-positives](<https://devfeed.tech/tags/false-positives.md>), [retention](<https://devfeed.tech/tags/retention.md>), [sast](<https://devfeed.tech/tags/sast.md>), [sast-tools](<https://devfeed.tech/tags/sast-tools.md>), [security](<https://devfeed.tech/tags/security.md>), [security-testing](<https://devfeed.tech/tags/security-testing.md>), [software-developers](<https://devfeed.tech/tags/software-developers.md>), [software-vulnerabilities](<https://devfeed.tech/tags/software-vulnerabilities.md>), [source-code](<https://devfeed.tech/tags/source-code.md>), [static](<https://devfeed.tech/tags/static.md>), [static-application-security-testing](<https://devfeed.tech/tags/static-application-security-testing.md>), [testing](<https://devfeed.tech/tags/testing.md>), [tools](<https://devfeed.tech/tags/tools.md>), [trust](<https://devfeed.tech/tags/trust.md>), [usability](<https://devfeed.tech/tags/usability.md>), [vulnerabilities](<https://devfeed.tech/tags/vulnerabilities.md>)

### AI overview

A review of 89 research works identifies false positives and other usability barriers as concerns that can weaken developers' trust in SAST tools. The thesis also presents a process that automates tool execution and formats findings to make them more meaningful and actionable. In a real-world use case, participants reported satisfaction with several aspects of the process and said it increased their willingness to use the SAST tool. The supplied text does not specify which tools were evaluated or provide further details about the process.

### Source excerpt

arXiv:2611.21621v1 Announce Type: new Abstract: As the Internet connects more of the world, software vulnerabilities create growing security risks. Because software developers are responsible for building and maintaining secure applications, they rely on tools and techniques that help identify vulnerabilities early in development. Static Application Security Testing (SAST) tools analyze source code to identify potential security weaknesses before software is deployed. Although SAST can help developers address vulnerabilities proactively, these tools also present usability and adoption challenges. This thesis examines those challenges and explores ways to improve the adoption, usability, and continued use of SAST. First, a literature review of 89 research works related to SAST implementation and continued usage identifies recurring developer concerns, including false positives and other usability barriers that can reduce trust in SAST results. Second, the thesis presents a process for automating the execution of SAST tools and formatting their output so that findings are more meaningful and actionable to developers. A real-world use case evaluates an implementation of this process and gathers developer feedback. Participants reported satisfaction with several aspects of the process and indicated that it increased their willingness to use the SAST tool.

## Missing Security-Fix Backporting for GitHub Actions Workflows

DevFeed: [Missing Security-Fix Backporting for GitHub Actions Workflows](<https://devfeed.tech/articles/missing-security-fix-backporting-for-github-actions-workflows-139608.md>)

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

Author: Chengyan Ma, Jieke Shi, Ruidong Han, Weifeng Sun, Yuqing Niu, Yunbo Lyu, Zhou Yang, David Lo

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

Content type: article

Language: en

Sources: [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: [GitHub Actions](<https://devfeed.tech/topics/github-actions.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>), [Static code analysis](<https://devfeed.tech/topics/static-code-analysis.md>), [GitHub](<https://devfeed.tech/topics/github.md>)

Tags: [actions](<https://devfeed.tech/tags/actions.md>), [automated](<https://devfeed.tech/tags/automated.md>), [backporting](<https://devfeed.tech/tags/backporting.md>), [backports](<https://devfeed.tech/tags/backports.md>), [branch](<https://devfeed.tech/tags/branch.md>), [ci-cd](<https://devfeed.tech/tags/ci-cd.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [github](<https://devfeed.tech/tags/github.md>), [github-actions](<https://devfeed.tech/tags/github-actions.md>), [llm](<https://devfeed.tech/tags/llm.md>), [maintenance](<https://devfeed.tech/tags/maintenance.md>), [matching](<https://devfeed.tech/tags/matching.md>), [patch](<https://devfeed.tech/tags/patch.md>), [release](<https://devfeed.tech/tags/release.md>), [release-branches](<https://devfeed.tech/tags/release-branches.md>), [scan](<https://devfeed.tech/tags/scan.md>), [scanner](<https://devfeed.tech/tags/scanner.md>), [security](<https://devfeed.tech/tags/security.md>), [security-fixes](<https://devfeed.tech/tags/security-fixes.md>), [semantic](<https://devfeed.tech/tags/semantic.md>), [workflows](<https://devfeed.tech/tags/workflows.md>)

### AI overview

An audit of GitHub Actions workflow histories found that 224,392 of 474,490 audited release branches remained vulnerable after a fix appeared on the default branch. Of 78,907 already-fixed branches, only 19,476 had plausible backports, at a median lag of 243 days. The study introduces WorkflowBP, which represents fixes as Workflow Semantic Patches and matches jobs and steps by content across divergent branches. A deterministic engine handles resolvable cases; an LLM synthesizes patches for the most divergent cases. On 12,000 unpatched workflow files, it produced scanner-checked backports for 67.9%. Developers confirmed or fixed 44 of 176 issues submitted with generated backports.

### Source excerpt

arXiv:2611.22519v1 Announce Type: new Abstract: GitHub natively supports workflow automation through GitHub Actions, now the dominant CI/CD tool on the platform. Yet keeping these workflows secure remains an ongoing burden: maintainers often patch a vulnerability on the default branch but leave the same flaw on the release and maintenance branches that downstream consumers continue to build from. Carrying a known fix onto these divergent branches, called backporting, is rarely done, and this paper presents the first large-scale empirical study quantifying the resulting gap. From a public corpus of GitHub Actions workflow histories, we mine 1,903,191 workflow-modifying commits, scan each before and after with the static scanner zizmor to identify 69,865 security fixes across 24,238 projects, and audit every release branch to check whether each fix was carried over. The gap is pervasive: 224,392 of 474,490 audited release branches remain vulnerable, and deliberate backporting is rare and slow, with only 19,476 of 78,907 already-fixed branches confirmed as plausible backports at a median lag of 243 days. We thus design WorkflowBP, the first technique for automated security-fix backporting of GitHub Actions workflows. WorkflowBP takes a neuro-symbolic approach: it compiles a default-branch fix into a domain-specific representation called the Workflow Semantic Patch (WSP) and applies it to each divergent branch by matching jobs and steps based on their content rather than their position, while an LLM synthesizes the WSP for the most divergent cases the deterministic engine cannot resolve. On 12,000 real unpatched workflow files from our study, WorkflowBP produces a scanner-checked backport for 67.9%. We further submit 176 issues with WorkflowBP-generated backports to real-world projects, 44 of which have been confirmed or fixed by developers.

## Natural Code Transformation Confuses Agents in Vulnerability Analysis

DevFeed: [Natural Code Transformation Confuses Agents in Vulnerability Analysis](<https://devfeed.tech/articles/natural-code-transformation-confuses-agents-in-vulnerability-analysis-139833.md>)

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

Author: Jie Zhu, Ronik Bhaskar, Heather Zheng, Ben Y. Zhao, Kexin Pei

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>), [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [code security](<https://devfeed.tech/topics/code-security.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Static code analysis](<https://devfeed.tech/topics/static-code-analysis.md>), [agentic-coding](<https://devfeed.tech/topics/agentic-coding.md>), [Claude Code](<https://devfeed.tech/topics/claude-code.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [code](<https://devfeed.tech/tags/code.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [defense](<https://devfeed.tech/tags/defense.md>), [discovery](<https://devfeed.tech/tags/discovery.md>), [research](<https://devfeed.tech/tags/research.md>), [transformation](<https://devfeed.tech/tags/transformation.md>), [vulnerability](<https://devfeed.tech/tags/vulnerability.md>)

### AI overview

Agents can find the same vulnerability with dramatically different success across real-world commits that preserve the same functionality, a pattern reported across multiple code domains and vulnerability categories. The study mines recurring development patterns to build a corpus of natural, functionality-preserving code transformations and evaluates them as a defense against attacker agents. It reports that even one transformation can reduce vulnerability-discovery success for frontier agents, including Claude Mythos 5.2 with Claude Code. The authors also examine agent failure modes, combining transformations, and adaptive attackers that try to reverse them; the supplied abstract gives no quantitative results or details on those comparisons.

### Source excerpt

arXiv:2610.14350v3 Announce Type: replace-cross Abstract: Having demonstrated a strong potential for automating vulnerability discovery, AI agents can also be used to attack software systems at scale. Today's software systems need mechanisms to level the playing field by slowing down potential attacks, giving them time to patch vulnerabilities and strengthen software. Along this line, our study of agent trajectories in vulnerability analysis shows a surprising finding: agents produce dramatically different results across real-world code commits that carry the same functionality and the same vulnerability. This phenomenon appears consistently in multiple code domains and vulnerability categories. It motivates us to study natural and functionality-preserving code transformations derived from real-world software development, and their potential as a defense against attacker agents. We build a corpus of natural transformations by mining recurring development patterns from real-world code commits, and apply them to evaluate impact on agentic vulnerability analysis. Our results show that even a single form of transformation can effectively "confuse" frontier agents, e.g., Claude Mythos 5.2 with Claude Code, reducing successes in vulnerability discovery. We also study different agent failures, whether transformations can be composed to provide stronger protection, and adaptive attackers who seek to reverse them. Overall, our study of natural code transformation significantly expands the research space of using code transformations to defend against malicious agents.

## How Chainguard's frontier AI harness keeps your code safe

DevFeed: [How Chainguard's frontier AI harness keeps your code safe](<https://devfeed.tech/articles/how-chainguard-s-frontier-ai-harness-keeps-your-code-safe-146249.md>)

Original publisher: [Read original article](<https://www.chainguard.dev/unchained/how-chainguards-frontier-ai-harness-keeps-your-code-safe>)

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

Content type: article

Language: en

Sources: [Chainguard: Unchained](<https://devfeed.tech/sources/chainguard-unchained.md>)

Topics: [Frontier AI](<https://devfeed.tech/topics/frontier-ai.md>), [chainguard](<https://devfeed.tech/topics/chainguard.md>), [Static code analysis](<https://devfeed.tech/topics/static-code-analysis.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [about](<https://devfeed.tech/tags/about.md>), [agent](<https://devfeed.tech/tags/agent.md>), [agent-swarm](<https://devfeed.tech/tags/agent-swarm.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agent](<https://devfeed.tech/tags/ai-agent.md>), [ai-harness](<https://devfeed.tech/tags/ai-harness.md>), [ai-labs](<https://devfeed.tech/tags/ai-labs.md>), [chainguard](<https://devfeed.tech/tags/chainguard.md>), [chainguard-harness](<https://devfeed.tech/tags/chainguard-harness.md>), [code](<https://devfeed.tech/tags/code.md>), [days](<https://devfeed.tech/tags/days.md>), [exploits](<https://devfeed.tech/tags/exploits.md>), [frontier](<https://devfeed.tech/tags/frontier.md>), [frontier-ai](<https://devfeed.tech/tags/frontier-ai.md>), [harness](<https://devfeed.tech/tags/harness.md>), [using](<https://devfeed.tech/tags/using.md>), [with](<https://devfeed.tech/tags/with.md>), [zero](<https://devfeed.tech/tags/zero.md>), [zero-days](<https://devfeed.tech/tags/zero-days.md>)

### AI overview

Chainguard Harness builds an application from source in an isolated microVM with no credentials or network egress, then uses frontier models from Anthropic, OpenAI, and Google to attack the running app and inspect first-party and dependency code. It replays each exploit in a fresh sandbox and reports it only if it succeeds consistently. Chainguard then creates a code-specific fix, checks that the exploit fails against the patched version, and has an engineer review each finding and fix. Teams receive reproducible, validated findings with fixes; for flaws in open-source dependencies, Chainguard says it coordinates disclosure with upstream maintainers. The article contrasts this workflow with high-volume model findings, publicly available models, and traditional scanners, which it says can leave teams with triage burdens, attacker parity, false positives, or no coverage of unknown bugs. These are the company's stated capabilities and comparisons.

### Source excerpt

Go on offense with Chainguard Harness, using frontier AI to uncover zero-days, verify exploits, and deliver fixes before attackers strike.

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

## Detectify launches Agentic Tooling to verify vulnerabilities in live applications

DevFeed: [Detectify launches Agentic Tooling to verify vulnerabilities in live applications](<https://devfeed.tech/articles/detectify-launches-agentic-tooling-to-verify-vulnerabilities-in-live-applications-137776.md>)

Original publisher: [Read original article](<https://www.helpnetsecurity.com/2026/11/17/detectify-agentic-tooling/>)

Author: Industry News

Published: 2026-11-17T14:13:55Z

Content type: news

Language: en

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

Topics: [Loop Engineering](<https://devfeed.tech/topics/loop-engineering.md>), [code security](<https://devfeed.tech/topics/code-security.md>), [Test automation](<https://devfeed.tech/topics/test-automation.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>), [Static code analysis](<https://devfeed.tech/topics/static-code-analysis.md>)

Tags: [agentic](<https://devfeed.tech/tags/agentic.md>), [agentic-tooling](<https://devfeed.tech/tags/agentic-tooling.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [applications](<https://devfeed.tech/tags/applications.md>), [code](<https://devfeed.tech/tags/code.md>), [detectify](<https://devfeed.tech/tags/detectify.md>), [devsecops](<https://devfeed.tech/tags/devsecops.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [environments](<https://devfeed.tech/tags/environments.md>), [exploited](<https://devfeed.tech/tags/exploited.md>), [industry-news](<https://devfeed.tech/tags/industry-news.md>), [launches](<https://devfeed.tech/tags/launches.md>), [ledger](<https://devfeed.tech/tags/ledger.md>), [live](<https://devfeed.tech/tags/live.md>), [organizations](<https://devfeed.tech/tags/organizations.md>), [probabilistic](<https://devfeed.tech/tags/probabilistic.md>), [tooling](<https://devfeed.tech/tags/tooling.md>), [verify](<https://devfeed.tech/tags/verify.md>), [vulnerabilities](<https://devfeed.tech/tags/vulnerabilities.md>)

### AI overview

Detectify's Agentic Tooling lets organizations' own AI agents investigate suspected vulnerabilities and test exploitability in live applications using Detectify testing engines. It runs in customers' environments through MCP and a CLI, with their own agents and models, on data they provide. In automated workflows, agents can take findings from code scans, bug bounties, red teams or attack-surface data, test them externally and produce evidence. The append-only Security Ledger records requests, payloads and results, links them to the original ticket, and helps teams distinguish tested findings from unsupported agent claims. Detectify says the approach addresses noisy AI-driven SAST output and aims to keep verification pace with rapid software delivery; the article notes the tooling builds on its MCP Server and that future integrations may trigger investigations from new platform data.

### Source excerpt

Detectify has launched Agentic Tooling. It lets organizations' own AI agents, running in their own environments, proactively investigate suspected vulnerabilities and test whether they can be exploited in running applications. A new Security Ledger lets security teams verify agents' findings against objective evidence, ensuring informed decisions rather than relying solely on probabilistic conclusions. The tools address a growing gap in DevSecOps. Engineering teams have built software factories that move code from commit to production in ... More -> The post Detectify launches Agentic Tooling to verify vulnerabilities in live applications appeared first on Help Net Security.

## 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, [...]

## TaintRadar: Semantic-Aware Taint-Style Vulnerability Detection via Augmented Code Property Graphs

DevFeed: [TaintRadar: Semantic-Aware Taint-Style Vulnerability Detection via Augmented Code Property Graphs](<https://devfeed.tech/articles/taintradar-semantic-aware-taint-style-vulnerability-detection-via-augmented-code-property-graphs-139237.md>)

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

Author: Elie Rizk, Firas Ben Hmida, Birhanu Eshete

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

Content type: article

Language: en

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

Topics: [Static code analysis](<https://devfeed.tech/topics/static-code-analysis.md>), [XSS](<https://devfeed.tech/topics/xss.md>)

Tags: [attack-paths](<https://devfeed.tech/tags/attack-paths.md>), [code-property-graph](<https://devfeed.tech/tags/code-property-graph.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [layers](<https://devfeed.tech/tags/layers.md>), [persistence](<https://devfeed.tech/tags/persistence.md>), [php](<https://devfeed.tech/tags/php.md>), [semantic](<https://devfeed.tech/tags/semantic.md>), [sql-injection](<https://devfeed.tech/tags/sql-injection.md>), [stored](<https://devfeed.tech/tags/stored.md>), [taint-analysis](<https://devfeed.tech/tags/taint-analysis.md>), [vulnerability-detection](<https://devfeed.tech/tags/vulnerability-detection.md>)

### AI overview

TaintRadar augments Code Property Graphs with three semantic layers to address limitations in static taint analysis: vulnerability-typed sanitization models node-level safety with transfer functions and context-sensitive parameter binding; persistence-aware propagation tracks flows across scripts through shared database states using schema constraints and query safety analysis; and object-aware reaching definitions model object-field changes across method boundaries with calling and bounded alias contexts. The abstract reports reduced false positives and 83% overall accuracy on SARD. Across 19 real-world PHP applications, TaintRadar reportedly rediscovered most known CVEs and found 30 confirmed zero-days (27 SQL injection, 3 stored XSS), assigned CVE identifiers.

### Source excerpt

arXiv:2607.16456v2 Announce Type: replace Abstract: Despite significant advances, static vulnerability analysis suffers from three critical limitations: coarse sanitization modeling (treating validation as a binary barrier), database blindness (breaking taint tracking across persistence layers), and shallow object-oriented analysis (missing field-level and interprocedural data flows). These flaws stem from a common root cause: Code Property Graph (CPG)-based taint analyses lack a compositional semantic layer to jointly model sanitization, persistence, and object aliasing. Consequently, existing tools generate excessive false positives or miss critical attack paths entirely. To address these limitations, we present TaintRadar, an approach that systematically augments CPGs with three independent semantic analysis layers. First, vulnerability-typed sanitization computes node-level safety guarantees using transfer functions and context-sensitive parameter binding. Second, persistence-aware propagation integrates database schema constraints and query safety analysis to track multi-script attack paths traversing shared database states. Finally, object-aware reaching definitions combine calling and bounded variable alias contexts to precisely model object-field mutations across method boundaries. We evaluate TaintRadar on synthetic benchmarks and real-world systems. On the SARD benchmark, TaintRadar reduces false positives while maintaining 83 percent overall accuracy. Across 19 real-world PHP applications, it rediscovered most known CVEs and uncovered 30 confirmed zero-day vulnerabilities: 27 SQL injection and 3 stored XSS vulnerabilities. These vulnerabilities have been assigned CVE identifiers. Our results show that semantic-aware graph augmentation improves the precision, coverage, and practical utility of static taint analysis.

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

## Small Harnesses, Default Checks, Limited Coverage: Bounded Model Checking in Practice

DevFeed: [Small Harnesses, Default Checks, Limited Coverage: Bounded Model Checking in Practice](<https://devfeed.tech/articles/small-harnesses-default-checks-limited-coverage-bounded-model-checking-in-practice-137986.md>)

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

Author: Kevin Kolyakov, Ricardo Calvo, James C. Davis, Paschal C. Amusuo

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

Content type: article

Language: en

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

Topics: [Automated reasoning](<https://devfeed.tech/topics/automated-reasoning.md>), [Static code analysis](<https://devfeed.tech/topics/static-code-analysis.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [ai](<https://devfeed.tech/tags/ai.md>), [analysis](<https://devfeed.tech/tags/analysis.md>), [artifacts](<https://devfeed.tech/tags/artifacts.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [automated](<https://devfeed.tech/tags/automated.md>), [automation](<https://devfeed.tech/tags/automation.md>), [bmc](<https://devfeed.tech/tags/bmc.md>), [bounded](<https://devfeed.tech/tags/bounded.md>), [c](<https://devfeed.tech/tags/c.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [coverage](<https://devfeed.tech/tags/coverage.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [dataset](<https://devfeed.tech/tags/dataset.md>), [environment](<https://devfeed.tech/tags/environment.md>), [errors](<https://devfeed.tech/tags/errors.md>), [execution](<https://devfeed.tech/tags/execution.md>), [function](<https://devfeed.tech/tags/function.md>), [guarantees](<https://devfeed.tech/tags/guarantees.md>), [model](<https://devfeed.tech/tags/model.md>), [small](<https://devfeed.tech/tags/small.md>)

### AI overview

An empirical study of bounded model checking in open-source C and Rust projects using CBMC and Kani finds diverse verification goals and generally small harnesses, alongside property-specification errors and frequent reliance on execution bounds and environment models. Most artifacts finish quickly and achieve high coverage within their stated scope, but repository-level coverage falls as project size grows. The findings motivate better property validation, harness generation, and ways to broaden verification.

### Source excerpt

arXiv:2611.19267v1 Announce Type: new Abstract: The growing use of AI to generate software and verification artifacts has increased the need for automated systems that provide reliable software assurance. Bounded model checking (BMC) offers a practical foundation for such systems by automatically checking correctness and security properties directly on software. However, effective verification requires choices about properties, input assumptions, function models, and execution bounds that influence the guarantees obtained. Little systematic evidence exists on how practitioners make these choices, limiting the empirical foundation for developing automated verification systems. We present an empirical study of BMC practices in open-source C and Rust projects using CBMC and Kani. Through LLM-assisted open coding, static analysis, and artifact execution, we characterize verification properties, artifact complexity, and verification outcomes. Our findings reveal diverse verification objectives and generally small harnesses, but also property-specification errors and extensive use of execution bounds and environment models. Most artifacts complete verification quickly and achieve high coverage within their scope, while repository-level coverage decreases with project size. Our findings and annotated dataset provide empirical baselines for verification automation and motivate improved techniques for property validation, harness generation, and scaling verification breadth.

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