# Code quality

Code quality is the assessment and improvement of software code's characteristics, including correctness, reliability, efficiency, maintainability, readability, and security.

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

## Measuring What Matters in the Age of AI: The Research Software Metrics Landscape

DevFeed: [Measuring What Matters in the Age of AI: The Research Software Metrics Landscape](<https://devfeed.tech/articles/measuring-what-matters-in-the-age-of-ai-the-research-software-metrics-landscape-142130.md>)

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

Author: Addi Malviya-Thakur, Reed Milewicz, Gregory R. Watson, Audris Mockus

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

Content type: article

Language: en

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

Topics: [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [Maintainability](<https://devfeed.tech/topics/maintainability.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Code quality](<https://devfeed.tech/topics/code-quality.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [ai-assisted-development](<https://devfeed.tech/tags/ai-assisted-development.md>), [attribution](<https://devfeed.tech/tags/attribution.md>), [automation](<https://devfeed.tech/tags/automation.md>), [capacity](<https://devfeed.tech/tags/capacity.md>), [challenges](<https://devfeed.tech/tags/challenges.md>), [code](<https://devfeed.tech/tags/code.md>), [community](<https://devfeed.tech/tags/community.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-ce](<https://devfeed.tech/tags/cs-ce.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [data](<https://devfeed.tech/tags/data.md>), [dependencies](<https://devfeed.tech/tags/dependencies.md>), [development](<https://devfeed.tech/tags/development.md>), [effort](<https://devfeed.tech/tags/effort.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [era](<https://devfeed.tech/tags/era.md>), [guidance](<https://devfeed.tech/tags/guidance.md>), [health](<https://devfeed.tech/tags/health.md>), [maintainability](<https://devfeed.tech/tags/maintainability.md>), [metrics](<https://devfeed.tech/tags/metrics.md>), [research](<https://devfeed.tech/tags/research.md>), [software](<https://devfeed.tech/tags/software.md>)

### AI overview

A focused synthesis of 49 substantive references groups research software metrics into eight families, assessed by data source, claimed construct, validity evidence, automation potential, and susceptibility to misuse. It finds that widely used metrics can be partial signals but are weak standalone measures of scientific impact. AI-assisted development sharpens gaps in provenance, generated-code maintainability, reviewer effort, dependencies, reuse and community-health signals, and credit for human work. The authors recommend contextual, mixed-method use and provide decision guidance for RSEs, principal investigators, institutions, and funders. Findings are limited to the focused review; a 727-record triaged corpus and reproducible search protocol are presented as groundwork for a future systematic mapping study.

### Source excerpt

arXiv:2611.23253v1 Announce Type: new Abstract: Research software now serves as a primary instrument of science, but the methods the community uses to judge its quality, sustainability, reuse, and impact remain scattered across software engineering, open science, FAIR software, citation, and research-assessment literature. AI-assisted development sharpens the problem: code can be produced at rates that outpace human review capacity, provenance and attribution are harder to track, scholarly credit systems cannot keep pace, and existing metrics inherit assumptions about how research software gets developed that may no longer apply. To aid in navigating these challenges, we present a focused landscape synthesis of research software metrics based on 49 substantive references, organizing the recurring metrics into eight families described by data source, claimed construct, evidence of validity, automation potential, and susceptibility to misuse. Many widely cited research software metrics serve as partial signals but make weak standalone measures of scientific impact. The AI era opens or widens gaps around provenance, maintainability of generated code, reviewer effort, model and data dependencies, reuse and community-health signal inflation, and credit for human labor that AI does not perform. We argue for responsible, contextual, mixed-method use of research software metrics, and offer decision guidance for Research Software Engineers (RSEs), principal investigators, institutions, and funders selecting metrics that support better software, fairer credit, and more trustworthy science. All findings rest on the 49-reference focused review; a reproducible search-and-triage protocol and a 727-record triaged corpus accompany the paper as a transparency artifact for a future full systematic mapping study.

## Validating Concurrent Correctness Witnesses with Ghosts by Thread-Modular Abstract Interpretation

DevFeed: [Validating Concurrent Correctness Witnesses with Ghosts by Thread-Modular Abstract Interpretation](<https://devfeed.tech/articles/validating-concurrent-correctness-witnesses-with-ghosts-by-thread-modular-abstract-interpretation-142195.md>)

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

Author: Michael Schwarz, Zhendong Ang, Umang Mathur

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

Content type: article

Language: en

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

Topics: [Code quality](<https://devfeed.tech/topics/code-quality.md>), [Tool](<https://devfeed.tech/topics/tool.md>), [synchronization](<https://devfeed.tech/topics/synchronization.md>)

Tags: [analysis](<https://devfeed.tech/tags/analysis.md>), [analyzer](<https://devfeed.tech/tags/analyzer.md>), [concurrent](<https://devfeed.tech/tags/concurrent.md>), [cs-pl](<https://devfeed.tech/tags/cs-pl.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [framework](<https://devfeed.tech/tags/framework.md>), [ghost](<https://devfeed.tech/tags/ghost.md>), [validating](<https://devfeed.tech/tags/validating.md>), [validation](<https://devfeed.tech/tags/validation.md>)

### AI overview

The proposed framework validates concurrent correctness witnesses by using ghost-variable semantics to guide thread-modular abstract interpretation. It first checks the semantic content of ghost instrumentation, then exploits that information during analysis. The approach covers resource invariants and phase ghosts; phase ghosts adjust how much the analysis considers interleavings, helping it validate invariants beyond unguided analysis while retaining scalability benefits. The framework is implemented in a static analyzer and evaluated on resource-invariant witnesses from a state-of-the-art verifier and hand-crafted witnesses containing phase information.

### Source excerpt

arXiv:2611.23792v1 Announce Type: cross Abstract: Concurrent programs are notoriously difficult to write and to reason about, and even tools based on sound theoretical foundations can produce incorrect results due to implementation bugs. Correctness witnesses have been proposed as a way to increase the confidence in the verdicts of software verifiers by enabling independent validation. Recently, correctness witnesses have been extended to the concurrent setting, by introducing ghost variables to allow encoding more expressive invariants. While different approaches to producing witnesses with ghosts exist, validation techniques are still lacking; instead of leveraging the information encoded in the ghosts to guide the validation process, validators merely treat ghost instrumentation and invariants over ghost variables as additional proof obligations. We propose a novel framework for the validation of concurrent correctness witnesses that exploits the semantic information encoded in ghost variables. It combines a checking phase, which establishes the semantic content of the ghost instrumentation, with an exploitation phase making use of this information. Both phases are formulated as thread-modular abstract interpretation. In particular, we consider two different classes of ghost variables and techniques for exploiting them, one based on resource invariants and one based on phases. Phase ghosts guide the degree to which the abstract interpretation considers interleavings instead of always abstracting them coarsely. In this way, the abstract interpreter can validate witnesses containing invariants beyond the reach of unguided thread-modular analysis, while still retaining its scalability benefits. We have implemented our framework in a static analyzer and evaluate it on witnesses encoding resource invariants obtained from a state-of-the-art software verifier, as well as on hand-crafted witnesses encoding phase information.

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

## Agent Trajectories as Evidence for Software Quality Assurance

DevFeed: [Agent Trajectories as Evidence for Software Quality Assurance](<https://devfeed.tech/articles/agent-trajectories-as-evidence-for-software-quality-assurance-139602.md>)

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

Author: Jonathan Ullrich, Julien Siebert, Michael Kl\\"as, Adam Trendowicz, Andreas Jedlitschka

Published: 2026-11-18T05: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: [agent observability](<https://devfeed.tech/topics/agent-observability.md>), [agentic-coding](<https://devfeed.tech/topics/agentic-coding.md>), [Software Process](<https://devfeed.tech/topics/software-process.md>), [Code quality](<https://devfeed.tech/topics/code-quality.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [agent](<https://devfeed.tech/tags/agent.md>), [agents](<https://devfeed.tech/tags/agents.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>), [autonomous](<https://devfeed.tech/tags/autonomous.md>), [autonomous-software](<https://devfeed.tech/tags/autonomous-software.md>), [can](<https://devfeed.tech/tags/can.md>), [causal-inference](<https://devfeed.tech/tags/causal-inference.md>), [changes](<https://devfeed.tech/tags/changes.md>), [code](<https://devfeed.tech/tags/code.md>), [continuous](<https://devfeed.tech/tags/continuous.md>), [contribution](<https://devfeed.tech/tags/contribution.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [develop](<https://devfeed.tech/tags/develop.md>), [quality](<https://devfeed.tech/tags/quality.md>), [quality-assurance](<https://devfeed.tech/tags/quality-assurance.md>), [software](<https://devfeed.tech/tags/software.md>), [software-quality-assurance](<https://devfeed.tech/tags/software-quality-assurance.md>)

### AI overview

The proposal treats observable software-agent trajectories as additional evidence for targeted quality assurance, alongside software and agent specifications and AI-generated artifacts. Reviewers could use trajectories to identify consequential decisions for scrutiny, investigate whether those decisions may have contributed to software problems, and improve specifications and development practices. The authors say this approach is plausible given industrial experience, execution records, and preliminary analysis methods, but trajectories alone cannot show that decisions were justified, outcomes acceptable, or corrective changes effective. The abstract frames evaluation and when simpler QA methods suffice as open questions.

### Source excerpt

arXiv:2611.22323v1 Announce Type: new Abstract: Autonomous software agents increasingly plan, implement, and test software with limited human oversight. Their decisions may introduce implicit assumptions that final code and passing tests do not adequately expose. We propose analyzing observable agent trajectories alongside software and agent specifications and AI generated artifacts as evidence for targeted quality assurance. The aim is to prioritize consequential decisions for scrutiny, investigate their possible contribution to software problems, and inform improvements to specifications and development practices. Industrial experience motivates the idea; available execution records and preliminary analysis methods make it plausible. However, trajectories alone do not establish that decisions are justified, outcomes acceptable, or corrective changes effective. We ask how this evidence can support review, diagnosis, and continuous quality improvement, and when simpler QA approaches suffice. Perspectives from requirements engineering, verification and validation, agent systems, causal inference, empirical software engineering, and human factors could help develop and evaluate the idea.

## I've stopped looking at the code

DevFeed: [I've stopped looking at the code](<https://devfeed.tech/articles/i-ve-stopped-looking-at-the-code-141152.md>)

Original publisher: [Read original article](<https://composables.com/blog/stopped-looking-at-the-code>)

Author: Alex Styl

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

Content type: opinion

Language: en

Sources: [Composables](<https://devfeed.tech/sources/composables-concise-no-fluff-video-tutorials-for-android-developers.md>)

Topics: [AI-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.md>), [Code quality](<https://devfeed.tech/topics/code-quality.md>), [Test automation](<https://devfeed.tech/topics/test-automation.md>), [User Interfaces](<https://devfeed.tech/topics/user-interfaces.md>)

Tags: [abstractions](<https://devfeed.tech/tags/abstractions.md>), [ai](<https://devfeed.tech/tags/ai.md>), [alex](<https://devfeed.tech/tags/alex.md>), [android](<https://devfeed.tech/tags/android.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [best-practices](<https://devfeed.tech/tags/best-practices.md>), [bugs](<https://devfeed.tech/tags/bugs.md>), [code](<https://devfeed.tech/tags/code.md>), [coding](<https://devfeed.tech/tags/coding.md>), [developers](<https://devfeed.tech/tags/developers.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [engineers](<https://devfeed.tech/tags/engineers.md>), [english](<https://devfeed.tech/tags/english.md>), [integration-tests](<https://devfeed.tech/tags/integration-tests.md>), [notifications](<https://devfeed.tech/tags/notifications.md>), [qa](<https://devfeed.tech/tags/qa.md>), [screen](<https://devfeed.tech/tags/screen.md>), [settings](<https://devfeed.tech/tags/settings.md>), [stateflow](<https://devfeed.tech/tags/stateflow.md>), [test](<https://devfeed.tech/tags/test.md>)

### AI overview

The author recommends giving AI the desired outcome, such as a settings screen for turning off notifications, instead of prescribing code abstractions and implementation details. They found the latter approach slow and prone to requiring close supervision. They argue that sound engineering practices, including architecture that can prevent some bugs, matter more when AI increases the pace of work. They suggest having AI write focused tests, with unit and integration tests kept separate, while emphasizing that the finished product still needs manual testing. The excerpt does not describe a particular AI tool or provide comparative results.

### Source excerpt

Stop micromanaging the AI

## Introducing GPT-6.2 Astra and Sol

DevFeed: [Introducing GPT-6.2 Astra and Sol](<https://devfeed.tech/articles/introducing-gpt-6-2-astra-and-sol-138356.md>)

Original publisher: [Read original article](<https://openai.com/index/introducing-gpt-6-2-astra-sol>)

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

Content type: release

Language: en

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

Topics: [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Frontier AI](<https://devfeed.tech/topics/frontier-ai.md>), [agentic-coding](<https://devfeed.tech/topics/agentic-coding.md>), [3D](<https://devfeed.tech/topics/3d.md>), [codex](<https://devfeed.tech/topics/codex.md>), [OpenAI](<https://devfeed.tech/topics/openai.md>), [Code quality](<https://devfeed.tech/topics/code-quality.md>)

Tags: [accounting](<https://devfeed.tech/tags/accounting.md>), [agentic-workflows](<https://devfeed.tech/tags/agentic-workflows.md>), [agents-last-exam](<https://devfeed.tech/tags/agents-last-exam.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-research](<https://devfeed.tech/tags/ai-research.md>), [ai-self-improvement](<https://devfeed.tech/tags/ai-self-improvement.md>), [alignment](<https://devfeed.tech/tags/alignment.md>), [api](<https://devfeed.tech/tags/api.md>), [astra](<https://devfeed.tech/tags/astra.md>), [chatgpt](<https://devfeed.tech/tags/chatgpt.md>), [chatgpt-work](<https://devfeed.tech/tags/chatgpt-work.md>), [codex](<https://devfeed.tech/tags/codex.md>), [coding](<https://devfeed.tech/tags/coding.md>), [computer-use](<https://devfeed.tech/tags/computer-use.md>), [cost](<https://devfeed.tech/tags/cost.md>), [efficiency](<https://devfeed.tech/tags/efficiency.md>), [gpt](<https://devfeed.tech/tags/gpt.md>), [gpt-6-2](<https://devfeed.tech/tags/gpt-6-2.md>), [gpt-6-2-astra](<https://devfeed.tech/tags/gpt-6-2-astra.md>), [product](<https://devfeed.tech/tags/product.md>), [sol](<https://devfeed.tech/tags/sol.md>)

### AI overview

GPT-6.2 Astra targets complex professional work, while GPT-6.2 Sol is positioned for everyday tasks; both are described as more token-efficient than their predecessors. Astra improves template-following in documents and slides, coding, computer use, and interactive 3D work. The source reports benchmark gains in professional, scientific, legal, spreadsheet, and 3D tasks, while Sol approaches Astra on one coding benchmark at about one-fifth the cost and beats GPT-6 Astra on LifeVal at about one-seventh the cost. Astra's API rates are $8 per million input tokens, $0.40 cached input, and $40 output; Sol retains GPT-6.1 Sol's $2, $0.10, and $10 rates. Both are available through ChatGPT Work, Codex, and the API, with Ultrafast access subject to plan or workspace eligibility. The models meet the stated Critical cybersecurity and High biological and chemical capability thresholds, so tighter safeguards restrict some legitimate security workflows. Astra also meets the High AI self-improvement threshold; the source describes added monitoring and controls. In two alignment tests, both models more often omitted obstacles that blocked their work, a behavior OpenAI says it is addressing.

### Source excerpt

Introducing GPT-6.2 Astra and Sol, with better professional outputs, coding, computer use, and efficiency at lower cost across ChatGPT Work, Codex, and the API.

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

## Automated Code Efficiency Optimization via Agent Skill Mining

DevFeed: [Automated Code Efficiency Optimization via Agent Skill Mining](<https://devfeed.tech/articles/automated-code-efficiency-optimization-via-agent-skill-mining-137922.md>)

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

Author: Zimu Wang, Yuling Shi, Mengfan Li, Zijun Liu, Jie M. Zhang, Chengcheng Wan, Xiaodong Gu

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

Content type: article

Language: en

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

Topics: [AI-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.md>), [Code quality](<https://devfeed.tech/topics/code-quality.md>), [Code](<https://devfeed.tech/topics/code.md>), [Test automation](<https://devfeed.tech/topics/test-automation.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agent-skill](<https://devfeed.tech/tags/agent-skill.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [candidate](<https://devfeed.tech/tags/candidate.md>), [code](<https://devfeed.tech/tags/code.md>), [cs-cl](<https://devfeed.tech/tags/cs-cl.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [efficiency](<https://devfeed.tech/tags/efficiency.md>), [feedback](<https://devfeed.tech/tags/feedback.md>), [filter](<https://devfeed.tech/tags/filter.md>), [framework](<https://devfeed.tech/tags/framework.md>), [instructions](<https://devfeed.tech/tags/instructions.md>), [language-models](<https://devfeed.tech/tags/language-models.md>), [libraries](<https://devfeed.tech/tags/libraries.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [pairs](<https://devfeed.tech/tags/pairs.md>), [paper](<https://devfeed.tech/tags/paper.md>), [pipeline](<https://devfeed.tech/tags/pipeline.md>), [skill](<https://devfeed.tech/tags/skill.md>), [tasks](<https://devfeed.tech/tags/tasks.md>), [tests](<https://devfeed.tech/tags/tests.md>), [transformation](<https://devfeed.tech/tags/transformation.md>)

### AI overview

EffiSkill uses persistent Operator Skill cards to guide code optimization: it distills language-specific libraries from slow/fast program pairs, then diagnoses new code, retrieves and composes skills, and generates up to eight candidates. Candidate generation does not use execution feedback; public tests filter and rank candidates, while held-out private tests determine reported correctness and speedup. Across 623 EffiBench-X tasks per language, two model backbones, and separate Python and C++ evaluations, EffiSkill had the highest observed OPT@1 and OPT@8 among compared methods in all four settings. Its OPT@8 lead over the strongest baselines ranged from 4.98 to 12.52 percentage points. The results support broader successful optimization coverage for the complete pipeline under a shared output budget.

### Source excerpt

arXiv:2603.27850v2 Announce Type: replace Abstract: Code efficiency is a fundamental aspect of software quality, yet how to use large language models (LLMs) to optimize correct programs remains challenging. Prior approaches rely on one-shot rewriting, retrieved exemplars or instructions, fine-tuning, or candidate search. In this paper, we present EffiSkill, a two-stage framework that models recurring slow-to-fast transformations as Operator Skills: persistent cards that record a transformation's intent, applicability, procedure, expected effect, and risks. Stage I distills frozen, language-specific skill libraries from slow/fast program pairs. Stage II diagnoses a new program, retrieves relevant skills, composes alternative plans, and generates up to eight candidates. These steps finish without candidate-execution feedback; public tests then filter and rank candidates, and held-out private tests determine reported correctness and speedup. Across 623 EffiBench-X tasks per language, two backbones, and separate Python and C++ evaluations, EffiSkill achieves the highest observed OPT@1 and OPT@8 among the compared methods in all four settings. Its OPT@8 margins over the strongest baselines range from 4.98 to 12.52 percentage points. These results support broader successful optimization coverage for the complete skill-guided pipeline under a shared output budget.

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

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

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

Author: William Franz Lamberti

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

Content type: news

Language: en

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

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

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

### AI overview

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

### Source excerpt

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

## Found, but Not Fixed : From Software Vulnerability Discovery to Fixes with Iterative LLM Pipelines

DevFeed: [Found, but Not Fixed : From Software Vulnerability Discovery to Fixes with Iterative LLM Pipelines](<https://devfeed.tech/articles/found-but-not-fixed-from-software-vulnerability-discovery-to-fixes-with-iterative-llm-pipelines-137992.md>)

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

Author: Youssef Gamal, Mohamad Fakih, Halima Bouzidi, Rahul Dharmaji, Gustavo Quiros Araya, Oluwatosin Ogundare, Mst Ayesha Siddika, Mohammad Abdullah Al Faruque

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

Topics: [code security](<https://devfeed.tech/topics/code-security.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [llm-reasoning](<https://devfeed.tech/topics/llm-reasoning.md>), [patches](<https://devfeed.tech/topics/patches.md>), [Code quality](<https://devfeed.tech/topics/code-quality.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [ai-assistants](<https://devfeed.tech/tags/ai-assistants.md>), [automated](<https://devfeed.tech/tags/automated.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [code](<https://devfeed.tech/tags/code.md>), [community](<https://devfeed.tech/tags/community.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [dataset](<https://devfeed.tech/tags/dataset.md>), [detection](<https://devfeed.tech/tags/detection.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [feedback](<https://devfeed.tech/tags/feedback.md>), [framework](<https://devfeed.tech/tags/framework.md>), [functions](<https://devfeed.tech/tags/functions.md>), [gemini](<https://devfeed.tech/tags/gemini.md>), [gemini-3](<https://devfeed.tech/tags/gemini-3.md>), [llm](<https://devfeed.tech/tags/llm.md>), [pipelines](<https://devfeed.tech/tags/pipelines.md>), [software](<https://devfeed.tech/tags/software.md>), [software-vulnerability](<https://devfeed.tech/tags/software-vulnerability.md>), [vulnerability](<https://devfeed.tech/tags/vulnerability.md>), [vulnerability-discovery](<https://devfeed.tech/tags/vulnerability-discovery.md>)

### AI overview

The paper proposes a multi-stage feedback loop using LLM reasoning to repair vulnerable functions, addressing code repair as a bottleneck after vulnerability detection. It benchmarks the pipeline against GPT-4o, GPT-5.1, and Gemini 3 Flash, and reports high-quality code repair. The authors say they provide an evaluation framework, fine-tuned weights, and an experimental dataset. The supplied abstract does not describe the pipeline's stages or provide comparative results.

### Source excerpt

arXiv:2611.19719v1 Announce Type: new Abstract: Software vulnerabilities persist as a critical threat despite the deployment of sophisticated detection tools and AI assistants. While detection has advanced, the subsequent code repair phase remains a primary bottleneck; manual intervention is inherently slow, costly, and prone to introducing secondary regressions and issues. In this paper, we investigate whether an iterative, LLM-based pipeline can provide a robust solution for the automated repair of vulnerable functions in real-world code. We propose a generalized framework that leverages the reasoning capabilities of Large Language Models (LLMs) through a multi-stage feedback loop. We benchmark this approach against state-of-the-art models, including GPT-4o, GPT-5.1, and Gemini 3 Flash, demonstrating that such a pipeline can achieve high-quality code repair. To support the broader security community, we provide our evaluation framework, fine-tuned weights, and comprehensive experimental dataset on our website: https://sites.google.com/view/llm4cve

## A Survey of Bugs in AI-Generated Code

DevFeed: [A Survey of Bugs in AI-Generated Code](<https://devfeed.tech/articles/a-survey-of-bugs-in-ai-generated-code-137916.md>)

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

Author: Ruofan Gao, Amjed Tahir, Peng Liang, Teo Susnjak, Ali Soltanian Fard Jahromi, Foutse Khomh

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

Content type: article

Language: en

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

Topics: [AI-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.md>), [Code quality](<https://devfeed.tech/topics/code-quality.md>), [Enhancing AI model performance](<https://devfeed.tech/topics/enhancing-ai-model-performance.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-assisted](<https://devfeed.tech/tags/ai-assisted.md>), [ai-assisted-coding](<https://devfeed.tech/tags/ai-assisted-coding.md>), [ai-generated-code](<https://devfeed.tech/tags/ai-generated-code.md>), [bugs](<https://devfeed.tech/tags/bugs.md>), [code](<https://devfeed.tech/tags/code.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [functional](<https://devfeed.tech/tags/functional.md>), [survey](<https://devfeed.tech/tags/survey.md>)

### AI overview

The survey reports that bugs are widespread in AI-generated code, with functional and stability bugs the most frequently reported categories across the reviewed studies; it attributes a substantial proportion to model hallucination. It identifies model size, instruction-following ability, and the quality and diversity of training data as factors influencing bug occurrence. Prompt engineering is widely used to mitigate bugs, but domain-specific and semantically complex issues can remain difficult to resolve automatically and require human intervention.

### Source excerpt

arXiv:2512.05239v2 Announce Type: replace Abstract: AI coding systems are increasingly used to help developers write code at scale, improving software development efficiency and boosting productivity. While these models and agents have shown strong performance, concerns persist regarding the quality of the AI-generated code. Although prior work has reported a range of quality issues associated with AI-generated code, these findings remain scattered and lack a systematic synthesis. A comprehensive review is lacking that demonstrates the bug types, patterns, distribution, their correlation with specific AI coding systems, and the remediation strategies proposed to address them. To fill this gap, we conduct a systematic literature review of existing studies on AI-generated code to develop a comprehensive understanding of bugs in the generated code and provide a foundation for future improvements in AI-assisted coding. Our results show that bugs are widespread in AI-generated code, with functional and stability bugs emerging as the most frequently reported categories across the reviewed studies, a substantial proportion of which is attributed to model hallucination. Model size, instruction-following capability, and the quality and diversity of training data are key factors influencing bug occurrence. To mitigate bugs, prompt engineering techniques are widely used; however, certain domain-specific or semantically complex issues remain difficult to resolve automatically and still require human intervention.

## Can Agentic LLMs Write Task-Based Parallel Code? A Study of OpenMP Tasking, HPX, StarPU and TTG

DevFeed: [Can Agentic LLMs Write Task-Based Parallel Code? A Study of OpenMP Tasking, HPX, StarPU and TTG](<https://devfeed.tech/articles/can-agentic-llms-write-task-based-parallel-code-a-study-of-openmp-tasking-hpx-starpu-and-ttg-136981.md>)

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

Author: Linus Bantel, Anna-Lena Roth, Tim Th\\"uring, Jonas Posner, Dirk Pfl\\"uger

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

Content type: article

Language: en

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

Topics: [hpx](<https://devfeed.tech/topics/hpx.md>), [agentic-coding](<https://devfeed.tech/topics/agentic-coding.md>), [generative-ai-tools](<https://devfeed.tech/topics/generative-ai-tools.md>), [Code quality](<https://devfeed.tech/topics/code-quality.md>), [scheduling](<https://devfeed.tech/topics/scheduling.md>)

Tags: [agentic](<https://devfeed.tech/tags/agentic.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [hpx](<https://devfeed.tech/tags/hpx.md>), [llm-agents](<https://devfeed.tech/tags/llm-agents.md>), [openmp](<https://devfeed.tech/tags/openmp.md>), [parallel](<https://devfeed.tech/tags/parallel.md>)

### AI overview

The study finds that model capability strongly shapes whether agentic LLMs can produce useful task-based C++ parallel code. Five locally hosted open-weight models iteratively edited, compiled, and ran seven HPC kernels across OpenMP Tasking, HPX, StarPU, TTG, and a serial baseline. Three models produced correct, genuinely task-parallel kernels in 57-82% of cases; two rarely compiled their code or succeeded. Among capable models, OpenMP Tasking and HPX were most reliable, StarPU close behind, and TTG trailed. The best generated matrix multiplication and factorization kernels matched or exceeded multithreaded OpenBLAS/LAPACK. But correctness alone overstated parallel quality: some nominally parallel kernels were serial, and serialized task graphs and poor task granularity were common. The abstract does not provide further detail on individual kernels or scaling and memory results.

### Source excerpt

arXiv:2611.19105v1 Announce Type: new Abstract: Task-based programming offers more expressive power than loop-level parallelism, but the runtimes providing it differ widely in API style, maturity, and the amount of public code to learn from. This paper asks how well LLM agents write C++ for four of them: OpenMP Tasking, HPX, StarPU, and TTG. Instead of single one-shot prompts, we use an agentic workflow in which the model edits files, compiles, and runs its kernels until it reproduces a reference output. Five locally hosted open-weight LLM implement seven HPC kernels, including matrix multiplication, Cholesky and LU factorization, in all four frameworks and a serial baseline to verify their understanding of the problem in general. Every kernel is evaluated independently for correctness at each concurrency level, strong scaling, and peak memory. Model capability dominates the outcome: three models produce correct, genuinely task-parallel kernels in 57-82% of the cases, while two models rarely compile their own code and almost never succeed. For the capable models, OpenMP Tasking and HPX are handled most reliably, StarPU is close behind, and TTG trails. The best generated GEMM and factorization kernels match or exceed the multithreaded OpenBLAS/LAPACK reference. However, correctness overstates parallel quality: several "parallel" kernels contain no parallelism at all; and serialized task graphs and unsuitable task granularity remain common.

## A Governance Methodology Layer for AI-Assisted Software Development: Defect Taxonomy, Controlled Ablation, and a Test of Process-Over-Capability

DevFeed: [A Governance Methodology Layer for AI-Assisted Software Development: Defect Taxonomy, Controlled Ablation, and a Test of Process-Over-Capability](<https://devfeed.tech/articles/a-governance-methodology-layer-for-ai-assisted-software-development-defect-taxonomy-controlled-ablation-and-a-test-of-process-over-capability-136484.md>)

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

Author: Sungjin Kwon

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

Content type: article

Language: en

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

Topics: [Code quality](<https://devfeed.tech/topics/code-quality.md>), [development-process](<https://devfeed.tech/topics/development-process.md>), [human review](<https://devfeed.tech/topics/human-review.md>), [Static code analysis](<https://devfeed.tech/topics/static-code-analysis.md>), [versioning](<https://devfeed.tech/topics/versioning.md>)

Tags: [ablation](<https://devfeed.tech/tags/ablation.md>), [ai-assisted](<https://devfeed.tech/tags/ai-assisted.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [defect](<https://devfeed.tech/tags/defect.md>), [governance](<https://devfeed.tech/tags/governance.md>), [methodology](<https://devfeed.tech/tags/methodology.md>), [taxonomy](<https://devfeed.tech/tags/taxonomy.md>), [test](<https://devfeed.tech/tags/test.md>)

### AI overview

The paper proposes a portable, file-based governance gate for AI-generated code and a version-controlled verification protocol that separates portable methodology from host automation. Its defect taxonomy distinguishes issues detectable by static analysis from those needing semantic review. In a small ablation (five artifacts), structured review had higher reported recall than a token-matched unstructured prompt, but blind re-grading withdrew a previously reported severity difference, and an independent retest found only a one-hit difference. Both approaches missed document-quality defects found by human QA. A later preregistered study of 184 runs found model tier had a larger strict-scoring effect than process design, so the evidence does not establish process as the dominant factor.

### Source excerpt

arXiv:2609.04218v4 Announce Type: replace Abstract: Autonomous coding agents produce output that passes syntactic checks -- compilation, type safety, CI -- at high velocity. Yet syntactic correctness does not imply semantic correctness: design boundaries, security invariants, and maintainability contracts remain structurally invisible to automated pipelines. This paper makes four contributions. First, we present a defect-class taxonomy grounded in five AI agent permission and governance modules, separating defects structurally detectable by static analysis from those requiring semantic review. Second, we describe a runtime-decoupled governance gate -- a file-based protocol that reads generator output and emits a structured verdict without API coupling, hence portable across generators. Third, we formalize methodology-as-code: expressing a verification protocol as a version-controlled, executable artifact whose two layers separate portable methodology from host automation. Fourth, we report a controlled ablation experiment (E-ablation, N=5 artifacts, 8-item independent ground truth) comparing harness-structured review against a token-matched unstructured prompt. The structured condition records 62% lenient recall against 50%, with 25% strict against 0%. A severity-grade differential reported earlier does not survive blind re-grading and is withdrawn (Sec. 6.6). An independent-session re-test with blind scoring does not replicate that contrast: the conditions differ by one strict hit in 24 (6/24 against 5/24), the structured aggregate again 25% and the unstructured 0% not recurring (Sec. 6.7). Both conditions miss document-quality defects identified by a human QA reviewer, indicating complementarity between structured AI review and human process inspection. A later pre-registered test varying model tier (184 runs) did not support process design as the dominant factor: under strict scoring the tier effect was larger (Sec. 6.8).

## Beyond Source Code: Evaluating Natural Language Specifications for LLM-Based C-to-Rust Translation

DevFeed: [Beyond Source Code: Evaluating Natural Language Specifications for LLM-Based C-to-Rust Translation](<https://devfeed.tech/articles/beyond-source-code-evaluating-natural-language-specifications-for-llm-based-c-to-rust-translation-136502.md>)

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

Author: Biruk Tadesse, Lawrence Arkoh, Marcelo D'Amorim, Wesley K. G. Assun\\c{c}\\~ao

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

Content type: comparison

Language: en

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

Topics: [Large Language Model](<https://devfeed.tech/topics/llm.md>), [LLM evaluation / benchmarking](<https://devfeed.tech/topics/llm-evaluation-benchmarking.md>), [Rust](<https://devfeed.tech/topics/rust.md>), [Code quality](<https://devfeed.tech/topics/code-quality.md>), [Transpilers](<https://devfeed.tech/topics/transpilers.md>), [lint](<https://devfeed.tech/topics/lint.md>)

Tags: [balance](<https://devfeed.tech/tags/balance.md>), [c](<https://devfeed.tech/tags/c.md>), [c-to-rust](<https://devfeed.tech/tags/c-to-rust.md>), [clippy](<https://devfeed.tech/tags/clippy.md>), [code-quality](<https://devfeed.tech/tags/code-quality.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [cost](<https://devfeed.tech/tags/cost.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [dataset](<https://devfeed.tech/tags/dataset.md>), [functional](<https://devfeed.tech/tags/functional.md>), [gpt-5-2](<https://devfeed.tech/tags/gpt-5-2.md>), [hypothesis](<https://devfeed.tech/tags/hypothesis.md>), [large-language-models-llms](<https://devfeed.tech/tags/large-language-models-llms.md>), [maintainability](<https://devfeed.tech/tags/maintainability.md>), [mini](<https://devfeed.tech/tags/mini.md>), [natural-language](<https://devfeed.tech/tags/natural-language.md>), [rust](<https://devfeed.tech/tags/rust.md>), [specifications](<https://devfeed.tech/tags/specifications.md>), [test](<https://devfeed.tech/tags/test.md>), [translation](<https://devfeed.tech/tags/translation.md>), [validation](<https://devfeed.tech/tags/validation.md>)

### AI overview

Across 300 IBM CodeNet programs evaluated with GPT-5.2 and GPT-4o-mini, code-only C-to-Rust translation had the highest test pass rate at 98.6%, but tended to preserve C implementation patterns. Specification-only translation produced more compact, idiomatic Rust, with about six times fewer unsafe blocks and 2.4 times fewer Clippy style warnings, but pass rates fell as low as 86% without validation. Iterative test-based validation and refinement raised specification-only performance to 95.3%. Combining source code and specifications achieved a 98.3% pass rate and the best balance of correctness and maintainability. The study also evaluated complexity and cost; the supplied abstract gives no specific results for those measures.

### Source excerpt

arXiv:2611.17581v1 Announce Type: new Abstract: Large language models (LLMs) have shown promising results for C-to-Rust translation, yet existing approaches primarily rely on source code as input, leaving natural-language specifications of program behavior underexplored as an alternative or complementary representation. We hypothesize that direct code translation encourages LLMs to preserve C-specific implementation choices, producing Rust that may be functionally correct but unnecessarily verbose, reliant on unsafe constructs, and less idiomatic. We investigate this hypothesis by comparing three translation settings: code-only, specification-only, and code-and-specification. Using 300 C programs from the IBM CodeNet dataset, we evaluate GPT-5.2 and GPT-4o-mini on functional correctness, maintainability, complexity, idiomaticity, unsafe construct usage, and cost. Code-only translation achieves the highest test pass rate (98.6%) but often mirrors C's implementation patterns. In contrast, specification-only translation produces the most idiomatic and compact Rust, reducing unsafe blocks by approximately 6x and Clippy style warnings by 2.4x. However, using specifications without validation yields test pass rates as low as 86% with our best performing model. Adding an iterative test-based validation and refinement step for specifications raises this to a 95.3% test pass rate. Overall, specification-based translation consistently improves code quality relative to code-only translation, while code-and-specification offers the best balance between correctness (98.3% test pass rate) and maintainability. Our study systematically compares these translation settings, highlighting the trade-offs among specification quality, translation correctness, code quality, and computational cost.

## Secure Code Through Quality: Why Speed Is No Longer Enough

DevFeed: [Secure Code Through Quality: Why Speed Is No Longer Enough](<https://devfeed.tech/articles/secure-code-through-quality-why-speed-is-no-longer-enough-137221.md>)

Original publisher: [Read original article](<https://www.harness.io/blog/code-quality-in-2027-everyone-got-fast-now-get-good>)

Author: Adam Arellano

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

Content type: opinion

Language: en

Sources: [Harness](<https://devfeed.tech/sources/harness-blog.md>)

Topics: [Code quality](<https://devfeed.tech/topics/code-quality.md>), [code security](<https://devfeed.tech/topics/code-security.md>), [Application Security](<https://devfeed.tech/topics/application-security.md>), [engineering-leadership](<https://devfeed.tech/topics/engineering-leadership.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-generated-code](<https://devfeed.tech/tags/ai-generated-code.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [assets](<https://devfeed.tech/tags/assets.md>), [code](<https://devfeed.tech/tags/code.md>), [code-quality](<https://devfeed.tech/tags/code-quality.md>), [developers](<https://devfeed.tech/tags/developers.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [environment](<https://devfeed.tech/tags/environment.md>), [exploited](<https://devfeed.tech/tags/exploited.md>), [exposed](<https://devfeed.tech/tags/exposed.md>), [frontier-models](<https://devfeed.tech/tags/frontier-models.md>), [guardrails](<https://devfeed.tech/tags/guardrails.md>), [internet](<https://devfeed.tech/tags/internet.md>), [kpis](<https://devfeed.tech/tags/kpis.md>), [quality](<https://devfeed.tech/tags/quality.md>), [shift](<https://devfeed.tech/tags/shift.md>), [speed](<https://devfeed.tech/tags/speed.md>), [visibility](<https://devfeed.tech/tags/visibility.md>)

### AI overview

The text argues that as AI makes code generation faster and flaws easier to find, organizations should prioritize code that works as intended and is safe and defensible. It recommends maintaining an inventory of software and the ability to identify vulnerability exposure quickly; restructuring systems to reduce internet exposure while preserving functionality; and shifting engineering priorities from feature deadlines toward refactoring, simpler code, and less exposure. Speed still matters for patching--PHP2Shell was reportedly exploited within hours--but the text says timely answers to leadership depend on patch management and visibility into what runs within company boundaries. It advocates governing the process from specification through production and runtime.

### Source excerpt

Shift from AI-generated code velocity to code quality by improving visibility, strengthening architecture, and prioritizing secure engineering practices. | Blog

## Sonar brings vulnerability intelligence to OpenAI Daybreak Defense Factory

DevFeed: [Sonar brings vulnerability intelligence to OpenAI Daybreak Defense Factory](<https://devfeed.tech/articles/sonar-brings-vulnerability-intelligence-to-openai-daybreak-defense-factory-131388.md>)

Original publisher: [Read original article](<https://www.sonarsource.com/blog/sonar-brings-vulnerability-intelligence-to-openai-daybreak/>)

Author: Brooks Naylor

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

Content type: release

Language: en

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

Topics: [Exploit](<https://devfeed.tech/topics/exploit.md>), [qualitygates](<https://devfeed.tech/topics/qualitygates.md>), [codex](<https://devfeed.tech/topics/codex.md>), [Code quality](<https://devfeed.tech/topics/code-quality.md>), [OpenAI](<https://devfeed.tech/topics/openai.md>)

Tags: [assessment](<https://devfeed.tech/tags/assessment.md>), [automated](<https://devfeed.tech/tags/automated.md>), [changes](<https://devfeed.tech/tags/changes.md>), [cli](<https://devfeed.tech/tags/cli.md>), [code](<https://devfeed.tech/tags/code.md>), [codex](<https://devfeed.tech/tags/codex.md>), [compliance](<https://devfeed.tech/tags/compliance.md>), [daybreak](<https://devfeed.tech/tags/daybreak.md>), [defense](<https://devfeed.tech/tags/defense.md>), [factory](<https://devfeed.tech/tags/factory.md>), [gate](<https://devfeed.tech/tags/gate.md>), [intelligence](<https://devfeed.tech/tags/intelligence.md>), [openai](<https://devfeed.tech/tags/openai.md>), [quality](<https://devfeed.tech/tags/quality.md>), [quality-gate](<https://devfeed.tech/tags/quality-gate.md>), [security](<https://devfeed.tech/tags/security.md>), [security-findings](<https://devfeed.tech/tags/security-findings.md>), [sonar](<https://devfeed.tech/tags/sonar.md>), [sonarqube](<https://devfeed.tech/tags/sonarqube.md>), [vulnerability](<https://devfeed.tech/tags/vulnerability.md>)

### AI overview

The integration brings SonarQube security findings into Codex Security for investigation and patching, with assessment results and code changes flowing back to SonarQube. Organizations can connect findings through the SonarQube importer in Codex Security, the SonarQube plugin for Codex, or SonarQube CLI. Fresh pull requests can then be checked against the Sonar quality gate; SonarQube provides independent verification and gatekeeping under organizational standards and compliance requirements.

### Source excerpt

SonarQube Cloud customers can now send security findings to Codex Security and confirm automated fixes against the Sonar quality gate. See how it works.

## SACS: A Code Smell Dataset using Semi-automatic Generation Approach

DevFeed: [SACS: A Code Smell Dataset using Semi-automatic Generation Approach](<https://devfeed.tech/articles/sacs-a-code-smell-dataset-using-semi-automatic-generation-approach-129137.md>)

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

Author: Hanyu Zhang, Tomoji Kishi

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

Content type: article

Language: en

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

Topics: [Dataset development](<https://devfeed.tech/topics/dataset-development.md>), [Data Quality](<https://devfeed.tech/topics/data-quality.md>), [Code quality](<https://devfeed.tech/topics/code-quality.md>)

Tags: [automatic](<https://devfeed.tech/tags/automatic.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [code-smell](<https://devfeed.tech/tags/code-smell.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [dataset](<https://devfeed.tech/tags/dataset.md>), [detection](<https://devfeed.tech/tags/detection.md>), [generation](<https://devfeed.tech/tags/generation.md>), [guidelines](<https://devfeed.tech/tags/guidelines.md>), [machine-learning](<https://devfeed.tech/tags/machine-learning.md>), [metrics](<https://devfeed.tech/tags/metrics.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [refactoring](<https://devfeed.tech/tags/refactoring.md>), [review](<https://devfeed.tech/tags/review.md>), [semi](<https://devfeed.tech/tags/semi.md>), [tool](<https://devfeed.tech/tags/tool.md>)

### AI overview

SACS is an open-source dataset for code-smell detection, with more than 10,000 labeled samples each for Long Method, Large Class, and Feature Envy. Its semi-automatic process uses generation rules to propose candidate samples, then multiple metrics to separate automatically accepted cases from ambiguous cases for manual review. Structured review guidelines and an annotation tool support that validation. The approach aims to balance the scalability of automatic generation with the label reliability of expert review. The supplied text describes the dataset and method but provides no evaluation results or further detail on label quality.

### Source excerpt

arXiv:2602.15342v4 Announce Type: replace Abstract: Code smell is a great challenge in software refactoring, which indicates latent design or implementation flaws that may degrade the software maintainability and evolution. Over the past of decades, the research on code smell has received extensive attention. Especially the researches applied machine learning-technique have become a popular topic in recent studies. However, one of the biggest challenges to apply machine learning-technique is the lack of high-quality code smell datasets. Manually constructing such datasets is extremely labor-intensive, as identifying code smells requires substantial development expertise and considerable time investment. In contrast, automatically generated datasets, while scalable, frequently exhibit reduced label reliability and compromised data quality. To overcome this challenge, in this study, we explore a semi-automatic approach to generate a code smell dataset with high quality data samples. Specifically, we first applied a set of automatic generation rules to produce candidate smelly samples. We then employed multiple metrics to group the data samples into an automatically accepted group and a manually reviewed group, enabling reviewers to concentrate their efforts on ambiguous samples. Furthermore, we established structured review guidelines and developed a annotation tool to support the manual validation process. Based on the proposed semi-automatic generation approach, we created an open-source code smell dataset, SACS, covering three widely studied code smells: Long Method, Large Class, and Feature Envy. Each code smell category includes over 10,000 labeled samples. This dataset could provide a large-scale and publicly available benchmark to facilitate future studies on code smell detection and automated refactoring.

## Verification is the factory's feedback system

DevFeed: [Verification is the factory's feedback system](<https://devfeed.tech/articles/verification-is-the-factory-s-feedback-system-127368.md>)

Original publisher: [Read original article](<https://www.sonarsource.com/blog/software-factory-is-only-as-trustworthy-as-its-verification/>)

Author: Brooks Naylor

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

Content type: article

Language: en

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

Topics: [Code quality](<https://devfeed.tech/topics/code-quality.md>), [Agentic AI](<https://devfeed.tech/topics/what-is-agentic-ai.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>), [Code review](<https://devfeed.tech/topics/code-review.md>), [trust](<https://devfeed.tech/topics/trust.md>)

Tags: [agentic](<https://devfeed.tech/tags/agentic.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-software-factory](<https://devfeed.tech/tags/ai-software-factory.md>), [code](<https://devfeed.tech/tags/code.md>), [factory](<https://devfeed.tech/tags/factory.md>), [feedback](<https://devfeed.tech/tags/feedback.md>), [software](<https://devfeed.tech/tags/software.md>), [software-factory](<https://devfeed.tech/tags/software-factory.md>), [sonar](<https://devfeed.tech/tags/sonar.md>), [system](<https://devfeed.tech/tags/system.md>), [trust](<https://devfeed.tech/tags/trust.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

The article argues that software factories earn trust through independent verification built into every development loop. Teams should turn each failure into a repeatable check and start with narrow, familiar work. Deterministic checks enforce written structural rules consistently; agentic checks use context to assess intent and anomalies. Both are needed, and verification should run independently of the agent that wrote the code. Sonar Vortex provides guidance and checks changes in the agentic loop against the SonarQube quality profile. In CI, SonarQube defines quality profiles and gates while Gitar reviews pull requests for logic and intent and iterates on fixes. SonarQube Remediation Agent handles maintenance issues in the background and rechecks fixes with the engine that identified them. The article cautions that excessive hard constraints can stall a factory, while vague checks can be gamed; issue descriptions and remediation guidance help agents address underlying problems. It also identifies ownership of context, skills, and verification as an unresolved organizational challenge.

### Source excerpt

Learn how deterministic and agentic verification build trust in your AI software factory. See how Sonar checks code in every loop. Read the recap.

## AI Writes the Code, but Senior Engineers Still Ship the Product

DevFeed: [AI Writes the Code, but Senior Engineers Still Ship the Product](<https://devfeed.tech/articles/ai-writes-the-code-but-senior-engineers-still-ship-the-product-127124.md>)

Original publisher: [Read original article](<https://hackernoon.com/ai-writes-the-code-but-senior-engineers-still-ship-the-product?source=rss>)

Author: Yaman Kavishwar

Published: 2026-11-10T11:32:55Z

Content type: opinion

Language: en

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

Topics: [AI-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.md>), [Code review](<https://devfeed.tech/topics/code-review.md>), [Code quality](<https://devfeed.tech/topics/code-quality.md>), [coding assistant](<https://devfeed.tech/topics/coding-assistant.md>), [Boilerplate](<https://devfeed.tech/topics/boilerplate.md>), [Pull Request](<https://devfeed.tech/topics/pull-request.md>), [DORA change failure rate](<https://devfeed.tech/topics/dora-change-failure-rate.md>), [ai code review](<https://devfeed.tech/topics/ai-code-review.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [ai-assisted-development](<https://devfeed.tech/tags/ai-assisted-development.md>), [ai-generated-code-review](<https://devfeed.tech/tags/ai-generated-code-review.md>), [ai-generated-technical-debt](<https://devfeed.tech/tags/ai-generated-technical-debt.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [bugs](<https://devfeed.tech/tags/bugs.md>), [business-logic](<https://devfeed.tech/tags/business-logic.md>), [code-quality](<https://devfeed.tech/tags/code-quality.md>), [developer-productivity](<https://devfeed.tech/tags/developer-productivity.md>), [dora](<https://devfeed.tech/tags/dora.md>), [engineering-management](<https://devfeed.tech/tags/engineering-management.md>), [human-in-the-loop-ai](<https://devfeed.tech/tags/human-in-the-loop-ai.md>), [review](<https://devfeed.tech/tags/review.md>), [software-delivery](<https://devfeed.tech/tags/software-delivery.md>), [speed](<https://devfeed.tech/tags/speed.md>)

### AI overview

AI coding tools can speed up boilerplate, test scaffolding and first drafts, but the excerpt argues that output still needs senior review: generated code can compile and pass its own tests while missing architecture, security, edge cases or business rules. It cites DORA findings of lower delivery throughput and stability with increased AI adoption, GitClear's reported rise in duplicated code, and Stack Overflow survey respondents' concerns about accuracy. The described workflow requires a named reviewer before generated code reaches main, asks reviewers to assess design as well as correctness, refactors near-duplicates, keeps pull requests small, and tracks change failure rate and time to restore alongside velocity. The author reports roughly twice-as-fast delivery on their projects without a stability drop; this is their experience, not a general result established by the excerpt.

### Source excerpt

AI coding tools speed up boilerplate, but DORA, GitClear and Stack Overflow data show why senior review still decides quality.

## Patch correctness in automated program repair: A five-dimensional evidence framework and cross-benchmark audit from classical repair to coding agents

DevFeed: [Patch correctness in automated program repair: A five-dimensional evidence framework and cross-benchmark audit from classical repair to coding agents](<https://devfeed.tech/articles/patch-correctness-in-automated-program-repair-a-five-dimensional-evidence-framework-and-cross-benchmark-audit-from-classical-repair-to-coding-agents-127239.md>)

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

Author: Shuai Wu, Yanna Feng, Yufang Li, Xue Li, Zhijun Wang, Bolun Liu, Weilin Cai

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

Content type: article

Language: en

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

Topics: [audit](<https://devfeed.tech/topics/audit.md>), [patches](<https://devfeed.tech/topics/patches.md>), [Code quality](<https://devfeed.tech/topics/code-quality.md>), [agentic-coding](<https://devfeed.tech/topics/agentic-coding.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [assessment](<https://devfeed.tech/tags/assessment.md>), [audit](<https://devfeed.tech/tags/audit.md>), [audits](<https://devfeed.tech/tags/audits.md>), [automated](<https://devfeed.tech/tags/automated.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [budget](<https://devfeed.tech/tags/budget.md>), [coding-agents](<https://devfeed.tech/tags/coding-agents.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [detection](<https://devfeed.tech/tags/detection.md>), [dimensions](<https://devfeed.tech/tags/dimensions.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [execution](<https://devfeed.tech/tags/execution.md>), [fault-detection](<https://devfeed.tech/tags/fault-detection.md>), [framework](<https://devfeed.tech/tags/framework.md>), [integrity](<https://devfeed.tech/tags/integrity.md>), [maintenance](<https://devfeed.tech/tags/maintenance.md>), [matrix](<https://devfeed.tech/tags/matrix.md>), [patch](<https://devfeed.tech/tags/patch.md>), [repair](<https://devfeed.tech/tags/repair.md>)

### AI overview

The report proposes a five-dimensional framework for evaluating how test evidence supports patch-correctness claims in classical repair systems and repository-level coding agents. It audits 39 benchmark and evaluation artifacts, coding 33 primary contributions for test provenance and exposure, behavioral scope, oracle basis and dependence, execution integrity, and label adjudication. Its comparative audits show that candidate populations, oracle rules, and execution budgets can change reported detection rates; additional tests may reveal faults while rejecting valid alternatives or lowering correct-repair yield under a fixed budget. For repository-level audits, it distinguishes reproducing an issue from discriminating among candidate patches, and automated discrepancy detection from requirements-based judgment. The proposed reporting protocol records uncertainty and validation cost alongside fault detection and valid-patch retention.

### Source excerpt

arXiv:2611.10837v1 Announce Type: new Abstract: Tests guide automated program repair and determine which candidate patches are reported as successful. Repository-level coding agents extend this feedback loop by generating tests and revising code after observing execution results. This technical report introduces a five-dimensional evidence profile and reporting protocol to audit how test observations support patch-correctness claims across classical repair systems and coding agents. We assemble an audit dataset of 39 benchmark and evaluation artifacts: 32 primary empirical studies, one institutional technical audit, and six prior taxonomic baselines. We code the 33 primary contributions along five dimensions: test provenance and exposure, behavioral scope, oracle basis and dependence, execution integrity, and label adjudication. The central distinction separates checks visible during repair search from evidence reserved for final assessment. Four worked comparative audits show how changed candidate populations, oracle rules, or execution budgets alter reported detection rates. Additional tests can expose missed faults while rejecting valid alternatives or reducing correct-repair yield under a fixed budget. Repository-level audits separate issue reproduction from candidate-patch discrimination and distinguish automated discrepancy detection from requirements-based adjudication. An evidence matrix links each coded decision to supporting passages and records shared benchmark ancestry. We specify a reporting protocol for repair benchmarks and maintenance pipelines that retains uncertain judgments and records validation cost alongside fault detection and valid-patch retention.

## A Judge Agent Closes the Reliability Gap in AI-Generated Scientific Simulation

DevFeed: [A Judge Agent Closes the Reliability Gap in AI-Generated Scientific Simulation](<https://devfeed.tech/articles/a-judge-agent-closes-the-reliability-gap-in-ai-generated-scientific-simulation-127183.md>)

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

Author: Chengshuai Yang

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

Content type: news

Language: en

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

Topics: [Code quality](<https://devfeed.tech/topics/code-quality.md>), [Finite Element Method (FEM)](<https://devfeed.tech/topics/finite-element-method.md>), [Uncertainty quantification LLMs](<https://devfeed.tech/topics/uncertainty-quantification-llms.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [ai](<https://devfeed.tech/tags/ai.md>), [automated](<https://devfeed.tech/tags/automated.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [certification](<https://devfeed.tech/tags/certification.md>), [code](<https://devfeed.tech/tags/code.md>), [convergence](<https://devfeed.tech/tags/convergence.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [data](<https://devfeed.tech/tags/data.md>), [domains](<https://devfeed.tech/tags/domains.md>), [error](<https://devfeed.tech/tags/error.md>), [failure](<https://devfeed.tech/tags/failure.md>), [language-models](<https://devfeed.tech/tags/language-models.md>), [pipeline](<https://devfeed.tech/tags/pipeline.md>), [reliability](<https://devfeed.tech/tags/reliability.md>), [simulation](<https://devfeed.tech/tags/simulation.md>), [specification](<https://devfeed.tech/tags/specification.md>), [test](<https://devfeed.tech/tags/test.md>)

### AI overview

The abstract reports that a Judge Agent automating mathematical checks--well-posedness, convergence, and error certification--reduced silent failures from 42% to 1.5% across 134 tests in 12 scientific domains. In a prospective benchmark of 72 blinded tasks from 12 scientists, success was 89% with automated error bounds versus 53% without the Judge (95% CI 80-95%). A clinical CT experiment, the only powered experiment (n=200), reached 99% of expert quality. Remaining failures concentrated at bifurcation points, where certifiability breaks down. The work also introduces the simulability class S and a structured, solver-independent specification format called spec.md.

### Source excerpt

arXiv:2603.25780v2 Announce Type: replace Abstract: Large language models can generate scientific simulation code, but the generated code silently fails on most non-textbook problems. We show that classical mathematical validation -- well-posedness, convergence, and error certification -- can be fully automated by a Judge Agent, reducing the silent-failure rate from 42% to 1.5% across 134 test cases spanning 12 scientific domains. The headline result comes from a prospective benchmark: 72 blinded tasks submitted by 12 independent scientists yield an 89% success rate (95% CI: [80%, 95%]) with automated error bounds, versus 53% without the Judge. On clinical CT (the only powered experiment, n = 200), the pipeline reaches 99% of expert quality. The residual 1.5% concentrates at bifurcation points where certifiability breaks down. We formalize this boundary through the simulability class S and introduce spec.md, a structured specification format that makes any scientific computation problem machine-readable and solver-independent. Code, data, and all 72 benchmark tasks are publicly archived.

## Governed Self-Improvement for a Local-First Security Analyzer: Baseline Measurements and a Preregistered Evaluation Protocol for Tantular Cyber

DevFeed: [Governed Self-Improvement for a Local-First Security Analyzer: Baseline Measurements and a Preregistered Evaluation Protocol for Tantular Cyber](<https://devfeed.tech/articles/governed-self-improvement-for-a-local-first-security-analyzer-baseline-measurements-and-a-preregistered-evaluation-protocol-for-tantular-cyber-126928.md>)

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

Author: Raditio Ghifiardi, Rifny Rachman

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

Content type: article

Language: en

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

Topics: [LLM security](<https://devfeed.tech/topics/llm-security.md>), [Local AI](<https://devfeed.tech/topics/local-ai.md>), [Audit-then-score](<https://devfeed.tech/topics/audit-then-score.md>), [Self Hosted AI Tools](<https://devfeed.tech/topics/self-hosted-ai-tools.md>), [Code quality](<https://devfeed.tech/topics/code-quality.md>)

Tags: [analyzer](<https://devfeed.tech/tags/analyzer.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [local-first](<https://devfeed.tech/tags/local-first.md>), [measurements](<https://devfeed.tech/tags/measurements.md>), [security](<https://devfeed.tech/tags/security.md>), [self-improvement](<https://devfeed.tech/tags/self-improvement.md>)

### AI overview

Tantular Cyber's v0.3.0 benchmark suggests its deterministic scanner combination performs better than Semgrep alone: precision/recall were 0.843/0.915 versus 0.818/0.766. Its locally served model provides advisory explanations in Bahasa Indonesia, but only 57% passed the evidence-grounding check, compared with 95% for a different 8B model under identical prompts. Re-scoring found that grounding failures cited identifiers absent from the displayed evidence; a prompt change also appeared to improve the score partly by citing nothing. The authors report silent model-file migration and unreproducible figures as evaluation hazards. They propose a privacy-conscious improvement process using code-free feedback, curated data, staged interventions from prompts to LoRA and weight-space edits, hard gates, and human release approval. The first cycle is preregistered, but no results for it are reported.

### Source excerpt

arXiv:2611.10425v1 Announce Type: new Abstract: Local-first security tools let organizations analyze code without sending it to third-party services, but the small language models they can run locally are weaker than hosted ones and are hard to improve without breaching the privacy guarantee that motivates them. We present Tantular Cyber, an open-source, read-only repository security analyzer that keeps deterministic scanner findings authoritative and confines a locally served language model to advisory explanations in Bahasa Indonesia. We report its measured v0.3.0 baseline on a synthetic, ground-truth benchmark: combining Semgrep with an interprocedural call-graph scanner yields precision 0.843 and recall 0.915 (Semgrep alone: 0.818 and 0.766). The advisory layer is the weak point: 57% of explanations met an evidence-grounding check, against 95% for a different 8B model under identical prompts. A forensic re-scoring of retained outputs shows that every grounding failure cites a code identifier absent from the evidence shown, and that a prompt change which appeared to raise grounding from 0.56 to 0.72 did so partly by citing nothing. We document two evaluation-validity hazards we encountered: silent model-file migration during a run and non-reproducible published figures. Building on these lessons and on constraint-aware evaluation from security operations research, we propose a governed self-improvement loop (code-free feedback, curated data, a cheapest-first intervention ladder from prompts to LoRA and weight-space edits, hard gates, and human release approval) and preregister the protocol by which its first cycle will be judged. We report no results for the loop itself.

## Using AI to Build AI: How Agentforce Engineers Scale Automation Without Sacrificing Reliability

DevFeed: [Using AI to Build AI: How Agentforce Engineers Scale Automation Without Sacrificing Reliability](<https://devfeed.tech/articles/using-ai-to-build-ai-how-agentforce-engineers-scale-automation-without-sacrificing-reliability-126488.md>)

Original publisher: [Read original article](<https://engineering.salesforce.com/using-ai-to-build-ai-how-agentforce-engineers-scale-automation-without-sacrificing-reliability/>)

Author: Fereydoon Vafaei

Published: 2026-11-09T19:02:12Z

Content type: news

Language: en

Sources: [Salesforce](<https://devfeed.tech/sources/salesforce-engineering-blog.md>)

Topics: [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [reliability-engineering](<https://devfeed.tech/topics/reliability-engineering.md>), [Test automation](<https://devfeed.tech/topics/test-automation.md>), [LLM observability](<https://devfeed.tech/topics/llm-observability.md>), [engineering-culture](<https://devfeed.tech/topics/engineering-culture.md>), [Ground truth / benchmark quality](<https://devfeed.tech/topics/ground-truth-benchmark-quality.md>), [Code quality](<https://devfeed.tech/topics/code-quality.md>), [reliable codebases](<https://devfeed.tech/topics/reliable-codebases.md>)

Tags: [agentforce](<https://devfeed.tech/tags/agentforce.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-engineering](<https://devfeed.tech/tags/ai-engineering.md>), [artificial-intelligence](<https://devfeed.tech/tags/artificial-intelligence.md>), [atlas](<https://devfeed.tech/tags/atlas.md>), [automation](<https://devfeed.tech/tags/automation.md>), [brain](<https://devfeed.tech/tags/brain.md>), [build](<https://devfeed.tech/tags/build.md>), [challenge](<https://devfeed.tech/tags/challenge.md>), [driving](<https://devfeed.tech/tags/driving.md>), [engine](<https://devfeed.tech/tags/engine.md>), [engineer](<https://devfeed.tech/tags/engineer.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [engineers](<https://devfeed.tech/tags/engineers.md>), [help](<https://devfeed.tech/tags/help.md>), [innovation](<https://devfeed.tech/tags/innovation.md>), [q-a](<https://devfeed.tech/tags/q-a.md>), [reasoning](<https://devfeed.tech/tags/reasoning.md>), [reliability](<https://devfeed.tech/tags/reliability.md>), [scale](<https://devfeed.tech/tags/scale.md>), [using](<https://devfeed.tech/tags/using.md>)

### AI overview

Salesforce's Agentforce team reports reducing typical Atlas Reasoning Engine bug resolution from two to four weeks to one or two days, while weekly availability reports reached 100% during the observed period. To support this, the team links incidents, fixes, code, Slack discussions, and bridge notes in a semantic knowledge base that removes outdated material. It evaluates AI work through scenario tests, replay, mutation testing, and checks of the full reasoning trajectory; different models judge work rather than judging their own, with engineers overseeing results. Agents can design, implement, review, and deploy changes to non-production environments, but require explicit human approval to merge to main or deploy to production. The team bases autonomy on verifiability, reversibility, available context, detectable failures, and risk. Reported code-review capacity is about 10 automated reviews at once; retrieval is measured by precision and recall. The excerpt says improvements vary by workflow.

### Source excerpt

In our Engineering Energizers Q&A series, we highlight the engineering minds driving innovation across Salesforce. Today, we spotlight Fereydoon Vafaei, a Principal Software Engineer on the Agentforce team, who faced a formidable challenge: using AI engineering automation to help build and maintain the Atlas Reasoning Engine, the brain of Agentforce, without allowing unreliable AI-generated work [...] The post Using AI to Build AI: How Agentforce Engineers Scale Automation Without Sacrificing Reliability appeared first on Salesforce Engineering Blog.

## Building Software: Speed Counts, But Quality Matters More

DevFeed: [Building Software: Speed Counts, But Quality Matters More](<https://devfeed.tech/articles/building-software-speed-counts-but-quality-matters-more-125601.md>)

Original publisher: [Read original article](<https://spin.atomicobject.com/software-speed-vs-quality/>)

Author: Jeff Williams

Published: 2026-11-09T13:00:42Z

Content type: opinion

Language: en

Sources: [Atomic Object](<https://devfeed.tech/sources/atomic-object.md>)

Topics: [Code quality](<https://devfeed.tech/topics/code-quality.md>), [engineering-leadership](<https://devfeed.tech/topics/engineering-leadership.md>), [engineering-culture](<https://devfeed.tech/topics/engineering-culture.md>), [Claude Code](<https://devfeed.tech/topics/claude-code.md>), [human review](<https://devfeed.tech/topics/human-review.md>), [Business, Industry, Usability, User Experience, User Research, Web Strategy](<https://devfeed.tech/topics/business-industry-usability-user-experience-user-research-web-strategy.md>)

Tags: [about](<https://devfeed.tech/tags/about.md>), [artificial-intelligence](<https://devfeed.tech/tags/artificial-intelligence.md>), [atomic](<https://devfeed.tech/tags/atomic.md>), [building](<https://devfeed.tech/tags/building.md>), [but](<https://devfeed.tech/tags/but.md>), [claude](<https://devfeed.tech/tags/claude.md>), [claude-code](<https://devfeed.tech/tags/claude-code.md>), [code](<https://devfeed.tech/tags/code.md>), [counts](<https://devfeed.tech/tags/counts.md>), [curiosity](<https://devfeed.tech/tags/curiosity.md>), [development](<https://devfeed.tech/tags/development.md>), [digital-health](<https://devfeed.tech/tags/digital-health.md>), [doesn-t](<https://devfeed.tech/tags/doesn-t.md>), [first](<https://devfeed.tech/tags/first.md>), [gap](<https://devfeed.tech/tags/gap.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [i](<https://devfeed.tech/tags/i.md>), [keyboard](<https://devfeed.tech/tags/keyboard.md>), [matters](<https://devfeed.tech/tags/matters.md>), [more](<https://devfeed.tech/tags/more.md>), [quality](<https://devfeed.tech/tags/quality.md>), [software](<https://devfeed.tech/tags/software.md>), [speed](<https://devfeed.tech/tags/speed.md>), [tools](<https://devfeed.tech/tags/tools.md>)

### AI overview

Agentic tools have spread across Atomic Spin's offices, and one team estimated that tools could have shortened an eight-week, two-developer engagement to five weeks; they used the time saved to improve quality. The harder constraint is now defining the right work and verifying results. Three of four managing partners independently raised the need for shared team practices and product knowledge. In healthcare, important workflows may be undocumented, so teams need to observe clinicians and involve people with relevant care expertise; changes also need clinical, security, quality, or regulatory review suited to their risk. More engineering capacity does not expand reviewers' limited time. The article recommends clarifying who defines and reviews work, identifying non-negotiable process steps, giving teams a practical starting point, and tracking user value, quality, and speed against a baseline. It also reports concerns about agent supervision fatigue and reduced colleague interaction, while noting that only one office raised fatigue.

### Source excerpt

This summer one of our most technical people said something that raised my curiosity. He has the Claude Code subscription. He read our process document. And when he sits down at the keyboard, he still doesn't know how to start. He wasn't complaining about the document. He was describing a gap, and I wanted to [...] The post Building Software: Speed Counts, But Quality Matters More appeared first on Atomic Spin.

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