# Refactoring

A software engineering technique for restructuring code while preserving its observable behavior.

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

## Programmable Distributions of Semantics-Preserving Variants for Evaluating Code Agents

DevFeed: [Programmable Distributions of Semantics-Preserving Variants for Evaluating Code Agents](<https://devfeed.tech/articles/programmable-distributions-of-semantics-preserving-variants-for-evaluating-code-agents-135001.md>)

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

Author: Hasan Najib Mahmud, Shreya Gupta, Isha Chaudhary, Nathaniel Enis, Ravi Mangal, Gagandeep Singh, Corina Pasareanu

Published: 2026-11-16T05: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>), [Refactoring](<https://devfeed.tech/topics/refactoring.md>), [AI-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.md>)

Tags: [agentic](<https://devfeed.tech/tags/agentic.md>), [agents](<https://devfeed.tech/tags/agents.md>), [claude](<https://devfeed.tech/tags/claude.md>), [claude-opus](<https://devfeed.tech/tags/claude-opus.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>), [distributions](<https://devfeed.tech/tags/distributions.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [frontier-models](<https://devfeed.tech/tags/frontier-models.md>), [kimi](<https://devfeed.tech/tags/kimi.md>), [minimax](<https://devfeed.tech/tags/minimax.md>), [opencode](<https://devfeed.tech/tags/opencode.md>), [probabilistic](<https://devfeed.tech/tags/probabilistic.md>), [programming-language](<https://devfeed.tech/tags/programming-language.md>), [qwen](<https://devfeed.tech/tags/qwen.md>), [refactoring](<https://devfeed.tech/tags/refactoring.md>), [reliability](<https://devfeed.tech/tags/reliability.md>), [robustness](<https://devfeed.tech/tags/robustness.md>), [semantics](<https://devfeed.tech/tags/semantics.md>), [swe-bench](<https://devfeed.tech/tags/swe-bench.md>), [swe-bench-pro](<https://devfeed.tech/tags/swe-bench-pro.md>)

### AI overview

The study tests whether code agents can resolve repository issues after surrounding code is rewritten into semantically equivalent variants. It introduces VDL, a probabilistic programming language for defining distributions of variants through randomly applied semantics-preserving transformations. Using a generic distribution, the authors evaluate mini-SWE agent and OpenCode with four underlying models on SWE-bench Verified and SWE-bench Pro. Resolve rates fall by as much as 6.7 percentage points, with significant drops in 6 of 16 configurations. Model robustness rankings do not hold across the two scaffolds, suggesting robustness depends on the scaffold-model pairing. The supplied abstract does not specify individual transformation types or per-configuration results.

### Source excerpt

arXiv:2608.18389v2 Announce Type: replace Abstract: Code agents are increasingly deployed to resolve real software issues, yet their reliability under superficial code variations remains poorly understood. We evaluate whether coding agents that repair repository-level issues remain reliable when the surrounding codebase is rewritten into a semantically equivalent form. We sample semantically equivalent variants of a repository from an explicitly defined distribution and compare the agent's resolve rate on them with that on the original. Different distributions reveal different aspects of an agent, such as its sensitivity to routine refactoring or to misleading code near the location of a fix. We develop VDL, a probabilistic programming language for expressing such distributions, whose programs randomly apply semantics-preserving transformations (SPTs) to a repository. For our evaluation, we use it to define a generic distribution that is not targeted at any particular failure mode. We evaluate two agentic scaffolds (mini-SWE agent and OpenCode), each backed by one of four frontier models (Claude Opus 4.5, Kimi K2.5, MiniMax M2.5, and Qwen 3.6-27B), on instances from SWE-bench Verified and SWE-bench Pro. Resolve rates drop by up to 6.7 percentage points, significantly in 6 of 16 configurations. No ranking of models by robustness holds across scaffolds, revealing a jagged robustness frontier.

## Spaghetti Architect: A Controlled Code Benchmark Generator, and What Its Own Comments Do to Model Scores

DevFeed: [Spaghetti Architect: A Controlled Code Benchmark Generator, and What Its Own Comments Do to Model Scores](<https://devfeed.tech/articles/spaghetti-architect-a-controlled-code-benchmark-generator-and-what-its-own-comments-do-to-model-scores-127196.md>)

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

Author: Yuxiang Ji

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

Content type: article

Language: en

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

Topics: [Refactoring](<https://devfeed.tech/topics/refactoring.md>), [scaling laws](<https://devfeed.tech/topics/scaling-laws.md>), [code comments](<https://devfeed.tech/topics/code-comments.md>), [Compilers and Linkers](<https://devfeed.tech/topics/compilers-and-linkers.md>)

Tags: [aggregation](<https://devfeed.tech/tags/aggregation.md>), [architect](<https://devfeed.tech/tags/architect.md>), [behaviour](<https://devfeed.tech/tags/behaviour.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [code](<https://devfeed.tech/tags/code.md>), [comment](<https://devfeed.tech/tags/comment.md>), [control](<https://devfeed.tech/tags/control.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>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [generator](<https://devfeed.tech/tags/generator.md>), [json](<https://devfeed.tech/tags/json.md>), [languages](<https://devfeed.tech/tags/languages.md>), [messy](<https://devfeed.tech/tags/messy.md>), [model](<https://devfeed.tech/tags/model.md>), [models](<https://devfeed.tech/tags/models.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [program](<https://devfeed.tech/tags/program.md>), [refactoring](<https://devfeed.tech/tags/refactoring.md>), [reference](<https://devfeed.tech/tags/reference.md>), [rendering](<https://devfeed.tech/tags/rendering.md>)

### AI overview

Spaghetti Architect generates deliberately messy programs in five languages from JSON descriptions, then compiles and runs them against reference outputs and labels them by size and messiness. This controlled setup lets researchers vary one property at a time. Across four tested models, removing generated comments lowered refactoring scores, with a larger drop for the weakest model; a preregistered replication found the same pattern at smaller magnitude. Comments also masked messiness-related score declines on both tasks, leading the authors to recommend evaluating comment-free code. Changing problem size reduced direct-answer aggregation accuracy to zero for all models, while changing literal values shifted scores by less than 0.012. The abstract says the generator, dataset, and evaluation records are open source.

### Source excerpt

arXiv:2607.18642v3 Announce Type: replace-cross Abstract: Code corpora mined from the wild cannot change one thing at a time: a program's behaviour, messiness and size vary together, and nothing marks the correct answer. We present Spaghetti Architect, a generator that turns a small JSON description of a program into deliberately messy programs in five languages. It compiles and runs every program, checks the output against a reference computed from the description, and labels each program by problem size and by messiness. This control lets us change one property at a time and still know the correct answer. The generator writes comments into its own output, so we first re-render identical code without them. Removing the comments lowers the refactoring score of all four models we tested, and lowers the weakest model's about ten times as much as the strongest model's; a pre-registered replication confirms the difference at a smaller magnitude. The comments also hide an effect: messiness leaves scores flat while they are present and lowers them on both tasks once they are gone. We therefore recommend evaluating on the comment-free rendering. Changing only problem size drives direct-answer aggregation accuracy to zero for every model, and changing only literal values moves scores by less than 0.012. The generator, the dataset and the evaluation records are open source.

## Characterizing Robustness in Semantic Code Clone Detection

DevFeed: [Characterizing Robustness in Semantic Code Clone Detection](<https://devfeed.tech/articles/characterizing-robustness-in-semantic-code-clone-detection-120782.md>)

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

Author: Zhiwei Xu, Weixian Deng, Xuyang Liu, Xiaolin Peng, Jiabao Gao, Tian Qiu, Hai Wan, Xibin Zhao

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

Content type: article

Language: en

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

Topics: [Refactoring](<https://devfeed.tech/topics/refactoring.md>), [test](<https://devfeed.tech/topics/test.md>)

Tags: [analysis](<https://devfeed.tech/tags/analysis.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [clone](<https://devfeed.tech/tags/clone.md>), [code](<https://devfeed.tech/tags/code.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [detection](<https://devfeed.tech/tags/detection.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [framework](<https://devfeed.tech/tags/framework.md>), [graph](<https://devfeed.tech/tags/graph.md>), [operators](<https://devfeed.tech/tags/operators.md>), [prompt](<https://devfeed.tech/tags/prompt.md>), [robustness](<https://devfeed.tech/tags/robustness.md>), [semantic](<https://devfeed.tech/tags/semantic.md>), [token](<https://devfeed.tech/tags/token.md>), [transformation](<https://devfeed.tech/tags/transformation.md>)

### AI overview

The study finds that semantic code clone detectors can be highly sensitive to behavior-preserving rewrites. Its Systematic Code Transformation (SCT) framework organizes 51 operators and evaluates 14 token, tree, graph, and prompt-based detectors across BigCloneBench, Google Code Jam, and OJClone. Among 25 token, tree, and graph detector-dataset combinations that began above 90% F1, 21 lost at least 10 percentage points when all operators were composed. Sensitivity varied by rewrite type and application intensity; edit counts and code growth alone did not explain it, and different constructions with matched locations and edit counts exposed different errors. The analysis also distinguishes losses in score separability from changed fixed-threshold decisions despite retained ranking, indicating that threshold recovery varies by failure mode. The abstract presents systematic transformation testing as a way to assess stability across equivalent implementations.

### Source excerpt

arXiv:2606.25272v2 Announce Type: replace Abstract: Semantic code clone detection seeks to recognize shared functionality across different implementations, making robustness to behavior-preserving changes central to its effectiveness. Prior studies have exposed failures under such changes, motivating a systematic examination of how sensitivity varies with the rewrites used for evaluation. We present Systematic Code Transformation (SCT), a framework organizing 51 operators by code level, target, and edit category, and evaluate 14 token, tree, graph, and prompt-based detectors on BigCloneBench, Google Code Jam, and OJClone. By comparing transformation groups, repeated application, and alternative constructions, we connect overall performance changes with specific rewriting conditions. Of 25 token, tree, and graph detector and dataset combinations starting above 90% F1, 21 lose at least 10 percentage points under the composition of all operators. These losses vary with transformation type and application intensity, but are not determined by edit counts or code growth alone. Even at matched locations and edit counts, alternative constructions can expose different errors despite similar aggregate losses. Further analysis distinguishes reduced score separability from changed fixed-threshold decisions with retained ranking ability, revealing different scope for threshold recovery. Overall, these findings show why benchmark effectiveness needs to extend to stable discrimination across equivalent implementations and how systematic transformation testing can assess that capability.

## Launder-Bench: Can Repository-Level Agentic Code Laundering Be Detected?

DevFeed: [Launder-Bench: Can Repository-Level Agentic Code Laundering Be Detected?](<https://devfeed.tech/articles/launder-bench-can-repository-level-agentic-code-laundering-be-detected-113516.md>)

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

Author: Yuntong Hu, Hongji Pu, Zimo Li, Ruomeng Li, Xiaotong Liu, Ziyuan Qin, Qiyue Li, Liang Zhao

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

Content type: news

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>), [Refactoring](<https://devfeed.tech/topics/refactoring.md>), [code analysis](<https://devfeed.tech/topics/code-analysis.md>), [Repository](<https://devfeed.tech/topics/repository.md>), [reproducibility](<https://devfeed.tech/topics/reproducibility.md>)

Tags: [agentic](<https://devfeed.tech/tags/agentic.md>), [auditing](<https://devfeed.tech/tags/auditing.md>), [bench](<https://devfeed.tech/tags/bench.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [clone](<https://devfeed.tech/tags/clone.md>), [code](<https://devfeed.tech/tags/code.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>), [detection](<https://devfeed.tech/tags/detection.md>), [domain](<https://devfeed.tech/tags/domain.md>), [hidden](<https://devfeed.tech/tags/hidden.md>), [independent](<https://devfeed.tech/tags/independent.md>), [modules](<https://devfeed.tech/tags/modules.md>), [pair](<https://devfeed.tech/tags/pair.md>), [provenance](<https://devfeed.tech/tags/provenance.md>), [real-world](<https://devfeed.tech/tags/real-world.md>), [repository](<https://devfeed.tech/tags/repository.md>), [rewrite](<https://devfeed.tech/tags/rewrite.md>), [similarity](<https://devfeed.tech/tags/similarity.md>), [static](<https://devfeed.tech/tags/static.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

Launder-Bench tests whether repository-scale code rewrites that preserve behavior can be traced to their source. Built from 282 repositories, it uses source-hidden reconstruction and execution-based verification, with 1,128 pairwise provenance cases and 229 source-attribution cases that allow abstention. Same-domain independent repositories provide reference bands for similarity without shared provenance. Existing methods perform poorly: the strongest static method reaches 0.66 AUROC on pairwise detection; repository encoders rank the true source first in up to 22% of attribution queries, but receive calibrated attribution credit in only 1-2%. The results show that ranking a similar repository does not by itself establish provenance.

### Source excerpt

arXiv:2611.01966v1 Announce Type: new Abstract: Coding agents can now rewrite repository-scale codebases while preserving tested behavior, creating a new challenge for plagiarism detection, license auditing, and software provenance. We ask whether such rewrites can still be traced to their source. Existing clone benchmarks emphasize fragments and bounded edits, while repository-transformation benchmarks evaluate functional correctness rather than provenance. Moreover, ranking the most similar source does not establish derivation when independent implementations can be similarly close. We define repository-level agentic code laundering and introduce Launder-Bench, to our knowledge the first repository-level benchmark for provenance under agentic rewriting, constructed from 282 real-world repositories. A source-hidden reconstruction protocol decomposes source behavior, reconstructs modules and repository structure, and retains rewrites only after execution-based verification. We evaluate the same provenance problem in two complementary settings: Launder-Bench-Pair contains 1,128 pairwise instances asking whether two repositories share provenance, while Launder-Bench-Attr contains 229 source-attribution instances asking which candidate is the source, with abstention when evidence is insufficient. Measured same-domain independent repositories establish how much similarity can arise without shared provenance and provide detector-specific reference bands. Existing methods remain far from saturating Launder-Bench: the strongest static method reaches only 0.66 AUROC on pairwise detection, while repository encoders rank the true source first on up to 22% of attribution queries but earn calibrated attribution credit on only 1-2%. These results reveal a systematic gap between relative code similarity and source-specific provenance evidence, providing a reproducible target for provenance detection under agentic rewriting.

## DIFUZZI: A Differential Fuzzing Tool for Code Functional Similarity Assessment

DevFeed: [DIFUZZI: A Differential Fuzzing Tool for Code Functional Similarity Assessment](<https://devfeed.tech/articles/difuzzi-a-differential-fuzzing-tool-for-code-functional-similarity-assessment-107376.md>)

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

Author: Simantika Bhattacharjee Dristi, Matthew B. Dwyer

Published: 2026-10-30T04:00:00Z

Content type: article

Language: en

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

Topics: [Fuzzing/Fuzz testing](<https://devfeed.tech/topics/fuzzing.md>), [Tool](<https://devfeed.tech/topics/tool.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Refactoring](<https://devfeed.tech/topics/refactoring.md>), [Programming Languages / Compilers](<https://devfeed.tech/topics/programming-languages-compilers.md>)

Tags: [assessment](<https://devfeed.tech/tags/assessment.md>), [behavior](<https://devfeed.tech/tags/behavior.md>), [code](<https://devfeed.tech/tags/code.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [differential-fuzzing](<https://devfeed.tech/tags/differential-fuzzing.md>), [fuzzing](<https://devfeed.tech/tags/fuzzing.md>), [generator](<https://devfeed.tech/tags/generator.md>), [generators](<https://devfeed.tech/tags/generators.md>), [input](<https://devfeed.tech/tags/input.md>), [llm](<https://devfeed.tech/tags/llm.md>), [machine-learning](<https://devfeed.tech/tags/machine-learning.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [refactoring](<https://devfeed.tech/tags/refactoring.md>), [semantic](<https://devfeed.tech/tags/semantic.md>), [similarity](<https://devfeed.tech/tags/similarity.md>), [software](<https://devfeed.tech/tags/software.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>), [tool](<https://devfeed.tech/tags/tool.md>)

### AI overview

DIFUZZI aims to make differential fuzzing easier to apply for assessing functional similarity between programs. Differential fuzzing can compare program behavior at scale, but constructing suitable input generators for a pair of programs often requires substantial manual effort. DIFUZZI adds an LLM-based generator synthesis step that is iteratively validated and repaired. The abstract frames this as an alternative to formal equivalence approaches, which it says do not scale or quantify degrees of similarity, and machine-learning approximations, which can miss subtle semantic differences. The supplied text does not report evaluation results.

### Source excerpt

arXiv:2610.38337v1 Announce Type: new Abstract: A range of software engineering tasks, such as optimization and refactoring, seek to preserve the behavior of software components and require methods to assess functional similarity. Research has explored formal approaches to prove functional equivalence and used machine learning methods to approximate it, but the former does not scale and does not quantify the extent of similarity and the latter struggles when subtle semantic differences are present. Differential fuzzing offers a scalable approach for differencing programs semantically, but applying it often requires substantial manual effort to construct input generators that are well-suited to a target pair of programs. To address this challenge, we introduce DIFUZZI, which incorporates an LLM-based generator synthesis step that is iteratively validated and repaired. By automating this step, DIFUZZI paves the way for broader applicability of differential fuzzing. We release DIFUZZI at https://github.com/Dristi123/difuzzi_tool, with a demonstration video at https://youtu.be/FlHNOHuo9WE

## When Modernization Breaks Working Code: A Single-File Study of LLMs on Legacy PHP

DevFeed: [When Modernization Breaks Working Code: A Single-File Study of LLMs on Legacy PHP](<https://devfeed.tech/articles/when-modernization-breaks-working-code-a-single-file-study-of-llms-on-legacy-php-107408.md>)

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

Author: Afridi Mahmud, Abid Hasan Khondaker, Sadif Ahmed, Md Nafiu Rahman, Rifat Shahriyar

Published: 2026-10-30T04:00:00Z

Content type: article

Language: en

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

Topics: [Legacy Modernization](<https://devfeed.tech/topics/legacy-modernization.md>), [Refactoring](<https://devfeed.tech/topics/refactoring.md>), [legacy systems](<https://devfeed.tech/topics/legacy-systems.md>), [test](<https://devfeed.tech/topics/test.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [all](<https://devfeed.tech/tags/all.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [avoid](<https://devfeed.tech/tags/avoid.md>), [based](<https://devfeed.tech/tags/based.md>), [behavior](<https://devfeed.tech/tags/behavior.md>), [best](<https://devfeed.tech/tags/best.md>), [better](<https://devfeed.tech/tags/better.md>), [but](<https://devfeed.tech/tags/but.md>), [change](<https://devfeed.tech/tags/change.md>), [code](<https://devfeed.tech/tags/code.md>), [compare](<https://devfeed.tech/tags/compare.md>), [context](<https://devfeed.tech/tags/context.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [easy](<https://devfeed.tech/tags/easy.md>), [file](<https://devfeed.tech/tags/file.md>), [legacy](<https://devfeed.tech/tags/legacy.md>), [llms](<https://devfeed.tech/tags/llms.md>), [modernization](<https://devfeed.tech/tags/modernization.md>), [php](<https://devfeed.tech/tags/php.md>), [study](<https://devfeed.tech/tags/study.md>)

### AI overview

In a study of 500 WordPress 4.0 PHP files modernized to PHP 8.3 without project context or execution feedback, LLMs often damaged working code. The untouched originals had 83 files passing all 630 behavioral checks; the best model's output had 59. Each model broke 32-51 working files and repaired at most 10, while Rector broke 7 and repaired 6. Only 37 of 511 modernization findings required a PHP 8.3 change. Even among compatible files needing no change, LLMs broke 36-60%, compared with Rector's 8%. Many regressions prevented files from loading, often due to PHP-rejected type declarations. The authors recommend evaluating modernization against an unchanged baseline and reporting modernization separately from behavioral preservation.

### Source excerpt

arXiv:2610.40269v1 Announce Type: new Abstract: Pasting a legacy file into an LLM and asking it to "modernize this" is an easy shortcut. But is the result better than leaving the code alone? In this paper, we study this single-file setting with five LLMs, each asked to modernize 100 WordPress 4.0 PHP files to PHP 8.3 while preserving behavior, with no project context or execution feedback. We evaluate every output with 630 hidden behavioral checks and 511 Rector-detected modernization findings. We compare against two baselines: the unchanged originals and the rule-based tool Rector. Often, the answer is no. Untouched, 83 files already pass every check; the best LLM leaves only 59. Each model breaks 32-51 working files while repairing at most 10, whereas Rector breaks 7 and repairs 6. Most of this damage is unnecessary. Only 37 findings (7 percent) require a change under PHP 8.3, yet in compatible files with no required change, the LLMs break 36-60 percent (Rector: 8 percent). The model with the highest modernization score is no more compatible than its closest competitors. Most regressed checks come from files that no longer load at all, often because of type declarations PHP itself rejects. These are errors that need no project context to avoid. Evaluations of LLM-based modernization should therefore measure against a no-change baseline and report modernization and behavioral preservation separately.

## SWE-Bench ProMax: Benchmarking Agents on Large-Scale Multilingual Code Refactoring

DevFeed: [SWE-Bench ProMax: Benchmarking Agents on Large-Scale Multilingual Code Refactoring](<https://devfeed.tech/articles/swe-bench-promax-benchmarking-agents-on-large-scale-multilingual-code-refactoring-107348.md>)

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

Author: Yuling Shi, Jinghan Xu, Kelin Fu, Wenhao Zeng, Shilin He, Lei Zhang, Yue Liu, Zelin Zhao, Terry Yue Zhuo, Jialun Cao, Siyu Ye, Tianyu Liu, Kai Cai, Shing-Chi Cheung, Xiaodong Gu

Published: 2026-10-30T04:00:00Z

Content type: article

Language: en

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

Topics: [Refactoring](<https://devfeed.tech/topics/refactoring.md>), [agentic-coding](<https://devfeed.tech/topics/agentic-coding.md>), [AI-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.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>), [ai-coding](<https://devfeed.tech/tags/ai-coding.md>), [ai-coding-agents](<https://devfeed.tech/tags/ai-coding-agents.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [audit](<https://devfeed.tech/tags/audit.md>), [behavior](<https://devfeed.tech/tags/behavior.md>), [bench](<https://devfeed.tech/tags/bench.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [benchmarking](<https://devfeed.tech/tags/benchmarking.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [best](<https://devfeed.tech/tags/best.md>), [c](<https://devfeed.tech/tags/c.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>), [large](<https://devfeed.tech/tags/large.md>), [refactoring](<https://devfeed.tech/tags/refactoring.md>), [scale](<https://devfeed.tech/tags/scale.md>), [swe-bench](<https://devfeed.tech/tags/swe-bench.md>)

### AI overview

SWE-Bench ProMax is a benchmark for testing agents on complex, behavior-preserving refactoring across many files. It contains 170 expert-curated tasks from real commits in Python, Java, TypeScript, Go, C, C++, and Rust. Curators rewrote issue descriptions for clarity, manually reviewed tests to remove overly narrow or broad checks, and filtered out tasks lacking complexity or cross-file scope. Tasks average 11.5 modified files and 261.6 lines of code. In experiments using two agent scaffolds, the best-performing model resolved 41.2% of tasks, suggesting the benchmark remains challenging for current agents.

### Source excerpt

arXiv:2608.09802v2 Announce Type: replace-cross Abstract: As AI coding agents take on increasingly complex, long-horizon software engineering tasks, existing benchmarks are rapidly saturating and their evaluation quality has come under serious scrutiny: a recent audit found that nearly 60% of unsolved SWE-bench Verified instances contain flawed tests -- either overly narrow tests that reject correct solutions or overly broad tests that check unstated requirements -- and that frontier models can verbatim reproduce gold patches from training data. Code refactoring, which requires coordinated, behavior-preserving changes across many files, offers a substantially harder and more realistic test of agent capability, yet remains underserved by current benchmarks. We introduce SWE-Bench ProMax, an expert-curated, multilingual code refactoring benchmark of 170 instances drawn from real commits across seven programming languages (Python, Java, TypeScript, Go, C, C++, and Rust). Every instance undergoes rigorous, multi-stage curation that directly addresses the quality problems identified in prior benchmarks: issue descriptions are rewritten from scratch to provide precise, unambiguous specifications, and test suites are manually reviewed to remove overly narrow and overly broad tests. Tasks with insufficient complexity or limited cross-file scope are filtered out, yielding a benchmark of challenging, large-scale refactoring tasks that average 11.5 modified files and 261.6 lines of code per instance, substantially exceeding the scale of existing benchmarks. Experiments with frontier models under two agent scaffolds show that the best model achieves only 41.2% resolve rate, confirming that SWE-Bench ProMax presents a meaningful and unsaturated challenge for current AI coding agents. Our benchmark is available at https://huggingface.co/datasets/swe-bench-promax/SWE-Bench-ProMax.

## Agentic Refactoring: An Empirical Study of AI Coding Agents

DevFeed: [Agentic Refactoring: An Empirical Study of AI Coding Agents](<https://devfeed.tech/articles/agentic-refactoring-an-empirical-study-of-ai-coding-agents-103598.md>)

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

Author: Kosei Horikawa, Hao Li, Yutaro Kashiwa, Bram Adams, Hajimu Iida, Ahmed E. Hassan

Published: 2026-10-28T04:00:00Z

Content type: article

Language: en

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

Topics: [agentic-coding](<https://devfeed.tech/topics/agentic-coding.md>), [Refactoring](<https://devfeed.tech/topics/refactoring.md>), [AI-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.md>), [Code quality](<https://devfeed.tech/topics/code-quality.md>), [codex](<https://devfeed.tech/topics/codex.md>), [Claude Code](<https://devfeed.tech/topics/claude-code.md>)

Tags: [adoption](<https://devfeed.tech/tags/adoption.md>), [agent](<https://devfeed.tech/tags/agent.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [agentic-coding](<https://devfeed.tech/tags/agentic-coding.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agent](<https://devfeed.tech/tags/ai-agent.md>), [ai-coding](<https://devfeed.tech/tags/ai-coding.md>), [ai-coding-agents](<https://devfeed.tech/tags/ai-coding-agents.md>), [ai-powered](<https://devfeed.tech/tags/ai-powered.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [autonomous](<https://devfeed.tech/tags/autonomous.md>), [claude](<https://devfeed.tech/tags/claude.md>), [claude-code](<https://devfeed.tech/tags/claude-code.md>), [code](<https://devfeed.tech/tags/code.md>), [code-quality](<https://devfeed.tech/tags/code-quality.md>), [coding](<https://devfeed.tech/tags/coding.md>), [coding-agents](<https://devfeed.tech/tags/coding-agents.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [refactoring](<https://devfeed.tech/tags/refactoring.md>), [study](<https://devfeed.tech/tags/study.md>)

### AI overview

In an analysis of 51,412 refactorings across open-source Java projects, AI agents explicitly targeted refactoring in 26.1% of commits. The detailed analysis covers 3,907 commits with explicit refactoring intent: agents made low-level, consistency-oriented changes somewhat more often than humans (27.6% vs. 24.4%), most commonly renaming variables and changing variable types. Agent motivations centered on maintainability (52.5%) and readability (28.1%), but these frequent low-level edits produced limited metric gains. Overall, agentic refactoring was associated with small but statistically significant structural improvements, especially in medium-level changes that reduced class size and complexity.

### Source excerpt

arXiv:2511.04824v2 Announce Type: replace Abstract: Agentic coding tools, such as OpenAI Codex, Claude Code, and Cursor, are changing how software is developed. These AI-powered systems function as autonomous teammates capable of planning and executing complex development tasks. Agents have become active participants in refactoring, a key practice for improving internal code quality without altering observable behavior. Despite their increasing adoption, there is little empirical understanding of how agentic refactoring is used in practice, how it compares to human-driven refactoring, and what impact it has on code quality. To address this gap, we present a large-scale study of AI agent-generated refactorings in real-world open-source Java projects, analyzing 51,412 refactoring instances across 12,256 pull requests and 14,998 commits based on the AIDev dataset. We find that refactoring is a common and intentional activity, with agents explicitly targeting refactoring in 26.1% of commits. The subsequent analyses of refactoring types, purposes, and code quality focus on the 3,907 commits (32,611 instances) with explicit refactoring intent. High-level refactorings form the largest category overall; however, agentic refactoring contains a slightly larger share of low-level, consistency-oriented edits than human refactoring (27.6% vs. 24.4%), and its two most frequent operations are Rename Variable (7.6%) and Change Variable Type (6.8%). Additionally, the stated motivations behind agentic refactoring focus overwhelmingly on internal quality concerns (52.5% maintainability and 28.1% readability), although the measured metric improvements from these frequent low-level refactorings remain limited. Finally, code quality metrics show that agentic refactoring yields small but statistically significant improvements in structural metrics, particularly for medium-level changes, reducing class size and complexity.

## How Stable Are LLM-Generated Proofs Under Program Refactoring? A Stress Test for Verifiable Code Generation

DevFeed: [How Stable Are LLM-Generated Proofs Under Program Refactoring? A Stress Test for Verifiable Code Generation](<https://devfeed.tech/articles/how-stable-are-llm-generated-proofs-under-program-refactoring-a-stress-test-for-verifiable-code-generation-103116.md>)

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

Author: Aravind Mandiga, Guoming Li

Published: 2026-10-28T04: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: [Refactoring](<https://devfeed.tech/topics/refactoring.md>), [Lean](<https://devfeed.tech/topics/lean.md>), [llm-reasoning](<https://devfeed.tech/topics/llm-reasoning.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>)

Tags: [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [code-generation](<https://devfeed.tech/tags/code-generation.md>), [comparisons](<https://devfeed.tech/tags/comparisons.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-lo](<https://devfeed.tech/tags/cs-lo.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [lean](<https://devfeed.tech/tags/lean.md>), [llm](<https://devfeed.tech/tags/llm.md>), [program](<https://devfeed.tech/tags/program.md>), [proofs](<https://devfeed.tech/tags/proofs.md>), [refactoring](<https://devfeed.tech/tags/refactoring.md>), [reference](<https://devfeed.tech/tags/reference.md>), [repair](<https://devfeed.tech/tags/repair.md>), [survival](<https://devfeed.tech/tags/survival.md>)

### AI overview

RefactorProof tests whether Lean proofs remain valid when programs are refactored without changing behavior. It evaluates 458 certified variants derived from 185 VERINA tasks, keeping specifications and proofs byte-for-byte fixed. Structural refactorings reveal low task-normalized proof survival rates: 4.3% for supplied reference proofs and 13.3-26.8% for specialized provers. On matched sets of 21-25 short, non-recursive tasks, the prover proofs had 15.6-20.3 percentage points higher overall unchanged-proof survival than reference artifacts; all three reported 95% confidence intervals exclude zero. Yet failure did not necessarily mean costly repair: predefined one-identifier edits fixed 51 of 54 eligible reference failures and 58 of 85 prover failures. The benchmark measures stability without proof edits, not ongoing proof-maintenance cost.

### Source excerpt

arXiv:2610.36328v1 Announce Type: new Abstract: Benchmarks for verifiable code generation usually test a proof against one fixed implementation. We ask whether the same proof remains valid after a program refactoring that preserves behavior. We introduce RefactorProof, which derives 458 Lean-certified variants from the 185 VERINA tasks that compile in our pinned environment while holding the specification and evaluated proof fixed byte-for-byte. VERINA supplies reference proofs for 46 tasks, all from its basic split; the primary model-versus-reference comparisons further match on 21-25 short, non-recursive tasks. Structural refactorings expose substantial brittleness across proof sources: task-normalized structural PSR is 4.3% for the supplied references and 13.3-26.8% for the specialized provers. On the matched tasks, specialized prover proofs nevertheless have higher overall unchanged-proof survival than the supplied reference artifacts: +15.6 points for DeepSeek-Prover-V2-7B, +18.8 for Goedel-Prover-V2-32B, and +20.3 for Goedel-Prover-V2-8B; all three 95% CIs exclude zero. The ordering persists after excluding universally survived T1 variants, under family-balanced aggregation, and under alternative deployable valid-proof selection rules. However, unchanged-proof failure is not the same as high repair cost: predefined one-identifier edits repair 51/54 eligible reference structural failures and 58/85 eligible prover failures. RefactorProof therefore measures unchanged-proof stability under program refactoring, not the cost of maintaining a proof after it breaks.

## Software Engineering LLMs: Why We Need Them and How Software Engineering Helps Build Them

DevFeed: [Software Engineering LLMs: Why We Need Them and How Software Engineering Helps Build Them](<https://devfeed.tech/articles/software-engineering-llms-why-we-need-them-and-how-software-engineering-helps-build-them-101751.md>)

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

Author: Amir M. Ebrahimi, Mohammed Mehedi Hasan, Seyed Shayan Daneshvar, Jiahuei Lin, Gopi Krishnan Rajbahadur, Ahmed E. Hassan

Published: 2026-10-27T04:00:00Z

Content type: article

Language: en

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

Topics: [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Fine-tuning](<https://devfeed.tech/topics/fine-tuning.md>), [Enhancing AI model performance](<https://devfeed.tech/topics/enhancing-ai-model-performance.md>), [Refactoring](<https://devfeed.tech/topics/refactoring.md>)

Tags: [case-study](<https://devfeed.tech/tags/case-study.md>), [coding](<https://devfeed.tech/tags/coding.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [developers](<https://devfeed.tech/tags/developers.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [fine-tuning](<https://devfeed.tech/tags/fine-tuning.md>), [language-models](<https://devfeed.tech/tags/language-models.md>), [large-language-models](<https://devfeed.tech/tags/large-language-models.md>), [large-language-models-llms](<https://devfeed.tech/tags/large-language-models-llms.md>), [llm](<https://devfeed.tech/tags/llm.md>), [llms](<https://devfeed.tech/tags/llms.md>), [pipeline](<https://devfeed.tech/tags/pipeline.md>), [python](<https://devfeed.tech/tags/python.md>), [refactoring](<https://devfeed.tech/tags/refactoring.md>), [repositories](<https://devfeed.tech/tags/repositories.md>), [repository](<https://devfeed.tech/tags/repository.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>), [tasks](<https://devfeed.tech/tags/tasks.md>), [tokens](<https://devfeed.tech/tags/tokens.md>), [training-data](<https://devfeed.tech/tags/training-data.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

An industrial case study finds that targeted software engineering training can improve a coding LLM's repository refactoring and issue resolution. RefactorForge combined refactoring knowledge, established SE tools, and verification to produce 4,572 verified training trajectories from 306 Python repositories. Incremental fine-tuning on this data improved RefactorBench by 18.00 percentage points and SWE-Bench ProMax by 7.06 points; under OpenCode, SWE-Bench Verified rose 4.97 points and SWE-Bench Pro rose 1.23 points. Improvements also persisted across other coding-agent harnesses, while results for greenfield repository generation were mixed. The authors propose embedding SE knowledge in training, applying engineering methods to model development and maintenance, and defining the capabilities SE-focused LLMs should acquire.

### Source excerpt

arXiv:2610.33851v1 Announce Type: new Abstract: Software engineering (SE) expertise can shape how coding large language models (LLMs) are trained and which engineering capabilities they acquire. We examine this role through an industrial case study of capability-focused training for a 92B-parameter coding LLM serving more than 100,000 developers. We demonstrate how established SE knowledge can guide the selection of engineering capabilities, the construction of verifiable training data, and the evaluation of model improvements. To target repository-level refactoring, we developed RefactorForge, a pipeline that combines refactoring knowledge, established SE tools, and verification techniques to construct training data. Across 306 Python repositories, RefactorForge generated 5,704 executable tasks and retained 4,572 verified teacher trajectories totaling 72.51 million tokens. Incremental supervised fine-tuning on these trajectories, accounting for 0.46% of the preceding coding mixture's tokens, improved RefactorBench performance by 18.00 percentage points and SWE-Bench ProMax performance by 7.06 points. Under OpenCode, these improvements extended to SWE issue resolution, with gains of 4.97 points on SWE-Bench Verified and 1.23 points on SWE-Bench Pro. Improvements also persisted across other coding-agent harnesses, while greenfield repository generation showed mixed results. We report lessons from constructing capability-focused training data and evaluating its effects across engineering workloads. Building on this industrial experience, we propose a research agenda for expanding SE's role in transforming coding LLMs into SE LLMs: incorporating SE knowledge into model training, applying engineering methods to model development and maintenance, and systematically defining the engineering capabilities these models should acquire.

## Agentic Verified Optimization of Real-World Software

DevFeed: [Agentic Verified Optimization of Real-World Software](<https://devfeed.tech/articles/agentic-verified-optimization-of-real-world-software-96634.md>)

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

Author: Zhe Ye, Udaya Ghai, Zhizhen Qin, Dawn Song, Soonho Kong

Published: 2026-10-23T04: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: [agentic-coding](<https://devfeed.tech/topics/agentic-coding.md>), [Lean](<https://devfeed.tech/topics/lean.md>), [Refactoring](<https://devfeed.tech/topics/refactoring.md>), [performance-optimization](<https://devfeed.tech/topics/performance-optimization.md>)

Tags: [agentic](<https://devfeed.tech/tags/agentic.md>), [algorithms](<https://devfeed.tech/tags/algorithms.md>), [applications](<https://devfeed.tech/tags/applications.md>), [behavior](<https://devfeed.tech/tags/behavior.md>), [coding-agents](<https://devfeed.tech/tags/coding-agents.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [cs-lo](<https://devfeed.tech/tags/cs-lo.md>), [cs-pl](<https://devfeed.tech/tags/cs-pl.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [differential-testing](<https://devfeed.tech/tags/differential-testing.md>), [dynamic-programming](<https://devfeed.tech/tags/dynamic-programming.md>), [faster](<https://devfeed.tech/tags/faster.md>), [framework](<https://devfeed.tech/tags/framework.md>), [functions](<https://devfeed.tech/tags/functions.md>), [go](<https://devfeed.tech/tags/go.md>), [lean-4](<https://devfeed.tech/tags/lean-4.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [performance](<https://devfeed.tech/tags/performance.md>), [proofs](<https://devfeed.tech/tags/proofs.md>), [real-world](<https://devfeed.tech/tags/real-world.md>), [repository](<https://devfeed.tech/tags/repository.md>), [rust](<https://devfeed.tech/tags/rust.md>), [software](<https://devfeed.tech/tags/software.md>), [specification](<https://devfeed.tech/tags/specification.md>)

### AI overview

The paper proposes agentic verified optimization: an agent must deliver a faster implementation and a machine-checked equivalence proof, using the existing implementation as the specification. It formulates function- and repository-level tasks in Lean 4. Since few real-world applications use Lean, Aqueduct migrates C, C++, Go, and Rust programs to native Lean and checks ports against the originals by differential testing. On 189 Verina reference implementations, agents produced faster proved rewrites for 156. Across 17 migrated applications, 92 proved rewrites sped up 47 of 51 scenarios; application-level gains were smaller, so choosing which functions to optimize remains important. The authors present these results as evidence that agents can optimize standalone functions and migrated applications, while noting challenges remain before production use.

### Source excerpt

arXiv:2610.30188v1 Announce Type: new Abstract: Program optimization aims to improve performance while preserving behavior. Coding agents can already make programs faster by changing algorithms, data structures, and execution strategies. However, existing equivalence checks mostly rely on tests, which agents have been shown to exploit, passing the tests without preserving the intended behavior. We propose agentic verified optimization, in which an agent produces a faster implementation together with a machine-checked proof of equivalence to the existing one. Because the existing implementation serves as the specification, the task avoids the specification-writing bottleneck of verified code generation, and recent advances in theorem proving make the proofs attainable. We formulate the task at the function and repository levels in Lean 4, where programs can be both executed and reasoned about. Few real-world applications are written in Lean, so we develop Aqueduct, an agentic framework that migrates C, C++, Go, and Rust programs into native Lean, validates each port by differential testing against its original. On the 189 reference implementations in Verina, agents produce faster proved rewrites for 156, including algorithmic changes such as replacing exponential recursion with dynamic programming. On 17 migrated applications, their 92 proved rewrites speed up 47 of 51 application scenarios. These application-level gains are smaller than the function-level ones, making the choice of functions to optimize an important problem. Current agents can thus already carry out verified optimization on both standalone functions and applications migrated from real programs. We discuss the remaining challenges and the steps toward verified optimization in production.

## Runtime Semantic Discovery for Evolving Action Alphabets

DevFeed: [Runtime Semantic Discovery for Evolving Action Alphabets](<https://devfeed.tech/articles/runtime-semantic-discovery-for-evolving-action-alphabets-94612.md>)

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

Author: Pietro Bernabei, Rosario Pugliese

Published: 2026-10-22T04:00:00Z

Content type: article

Language: en

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

Topics: [Refactoring](<https://devfeed.tech/topics/refactoring.md>), [Automated reasoning](<https://devfeed.tech/topics/automated-reasoning.md>)

Tags: [actions](<https://devfeed.tech/tags/actions.md>), [alphabet](<https://devfeed.tech/tags/alphabet.md>), [behavioral-model](<https://devfeed.tech/tags/behavioral-model.md>), [cs-fl](<https://devfeed.tech/tags/cs-fl.md>), [cs-pl](<https://devfeed.tech/tags/cs-pl.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [discovery](<https://devfeed.tech/tags/discovery.md>), [evolution](<https://devfeed.tech/tags/evolution.md>), [execution](<https://devfeed.tech/tags/execution.md>), [lightweight](<https://devfeed.tech/tags/lightweight.md>), [local](<https://devfeed.tech/tags/local.md>), [monitors](<https://devfeed.tech/tags/monitors.md>), [observable](<https://devfeed.tech/tags/observable.md>), [operational](<https://devfeed.tech/tags/operational.md>), [runtime](<https://devfeed.tech/tags/runtime.md>), [semantic](<https://devfeed.tech/tags/semantic.md>), [similarity](<https://devfeed.tech/tags/similarity.md>), [software](<https://devfeed.tech/tags/software.md>), [software-systems](<https://devfeed.tech/tags/software-systems.md>), [specifications](<https://devfeed.tech/tags/specifications.md>), [traces](<https://devfeed.tech/tags/traces.md>), [updates](<https://devfeed.tech/tags/updates.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

Runtime semantic discovery uses local execution-trace contexts to identify candidate correspondences between actions in systems whose observable alphabets have changed. The paper defines k-neighbor equivalences based on the neighboring actions around each action, enabling runtime comparison without reconstructing a global behavioral model. These inferred correspondences may help adapt monitors and specifications under selected kinds of alphabet evolution. The method is intentionally lightweight: it does not fully characterize behavioral preservation, and neighbor-based equivalence has limitations.

### Source excerpt

arXiv:2610.28682v1 Announce Type: new Abstract: Runtime Verification typically assumes a fixed alphabet of observable actions. This assumption becomes fragile in evolving software systems, where updates, reconfigurations, or architectural changes may rename, split, or fuse actions while preserving the system's high-level intent. In these cases, previously valid monitors and specifications may become misaligned with the running system. In this paper, we study runtime semantic discovery, namely the problem of identifying whether newly observed actions play the same operational role as previously known ones, without reconstructing a global behavioral model. To this end, we propose a local and runtime-computable notion of action similarity based on the neighbor contexts in which actions occur within execution traces. We define a family of k-neighbor equivalences and use them to compare systems whose observable alphabets differ. Our approach is intentionally lightweight: it does not aim to fully characterize behavioral preservation, but rather to identify candidate semantic correspondences between actions in evolving systems. We discuss the expressive power and limitations of neighbor-based equivalence and show how inferred correspondences can support the adaptation of runtime monitors and specifications under selected classes of alphabet evolution.

## Maintaining quality while agents write the code

DevFeed: [Maintaining quality while agents write the code](<https://devfeed.tech/articles/maintaining-quality-while-agents-write-the-code-62044.md>)

Original publisher: [Read original article](<https://www.blog4ems.com/p/maintaining-quality-agentic-engineering>)

Author: Stephane Moreau

Published: 2026-09-29T11:12:45Z

Content type: opinion

Language: en

Sources: [Blog for Engineering Managers](<https://devfeed.tech/sources/blog-for-engineering-managers.md>)

Topics: [AI-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.md>), [rachels-ramblings](<https://devfeed.tech/topics/rachels-ramblings.md>), [Code review](<https://devfeed.tech/topics/code-review.md>), [Refactoring](<https://devfeed.tech/topics/refactoring.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [co-founder](<https://devfeed.tech/tags/co-founder.md>), [code](<https://devfeed.tech/tags/code.md>), [engineering-manager](<https://devfeed.tech/tags/engineering-manager.md>), [opencode](<https://devfeed.tech/tags/opencode.md>), [quality](<https://devfeed.tech/tags/quality.md>)

### AI overview

AI coding agents can produce code and pull requests quickly, but engineers still need to review the small design decisions and understand how changes fit the system. The article argues that maintaining a useful mental model of concurrent agent output remains part of engineering work.

### Source excerpt

Agents can write code in seconds. Your team still needs to understand what it does.

## Pixel Canary is now available in stealth for free on AI Gateway

DevFeed: [Pixel Canary is now available in stealth for free on AI Gateway](<https://devfeed.tech/articles/pixel-canary-is-now-available-in-stealth-for-free-on-ai-gateway-60178.md>)

Original publisher: [Read original article](<https://vercel.com/changelog/pixel-canary-is-now-available-in-stealth-for-free-on-ai-gateway>)

Author: Eric Dodds

Published: 2026-09-25T00:00:00Z

Content type: release

Language: en

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

Topics: [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Code](<https://devfeed.tech/topics/code.md>), [gateway](<https://devfeed.tech/topics/gateway.md>), [Front end](<https://devfeed.tech/topics/frontend.md>), [Next.js](<https://devfeed.tech/topics/next-js.md>), [Vercel](<https://devfeed.tech/topics/vercel.md>), [Refactoring](<https://devfeed.tech/topics/refactoring.md>), [Mobile](<https://devfeed.tech/topics/mobile.md>), [API keys](<https://devfeed.tech/topics/api-keys.md>), [Optimization](<https://devfeed.tech/topics/optimization.md>), [Vercel CLI](<https://devfeed.tech/topics/vercel-cli.md>), [view transitions](<https://devfeed.tech/topics/view-transitions.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-gateway](<https://devfeed.tech/tags/ai-gateway.md>), [api-keys](<https://devfeed.tech/tags/api-keys.md>), [cli](<https://devfeed.tech/tags/cli.md>), [coding-agent](<https://devfeed.tech/tags/coding-agent.md>), [frontend](<https://devfeed.tech/tags/frontend.md>), [next-js](<https://devfeed.tech/tags/next-js.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [refactoring](<https://devfeed.tech/tags/refactoring.md>), [vercel](<https://devfeed.tech/tags/vercel.md>)

### AI overview

Vercel announces that Pixel Canary is available on AI Gateway in stealth at no cost for a limited time. The model is positioned for coding, frontend development, mobile app design, and code refactoring, with reported results on Next.js evaluation tasks. The release also describes setup through the Vercel CLI and AI Gateway features such as API key budgets, usage and cost tracking, and routing rules.

### Source excerpt

Pixel Canary is now available on AI Gateway as stealth/pixel-canary. It's free for a limited time while in stealth. Pixel Canary is strong at coding, including building applications and refactoring existing code. It is well suited to frontend development and mobile app design, from responsive layouts and app screens to navigation and interactive components. On Next.js evals, Pixel Canary ties GPT 6 Astra (high) at a 90.3% baseline success rate, passing 28 of 31 tasks. With Next.js documentation supplied through AGENTS.md, it passes 30 of 31 tasks (96.8%), tying the leaderboard's top score in that setting. It passes tasks covering App Router migrations, data fetching, image and font optimization, caching, and view transitions, demonstrating its ability to implement and update the code behind web interfaces. Scores use pass@4: a task passes if any of up to four attempts succeeds. ZDR is not available for this model, and prompts and responses sent through it may be used for training and model improvement. To get started, set model to stealth/pixel-canary: To use Pixel Canary in your coding agent, run the setup command with the Vercel CLI: The command detects installed agents, provisions or reuses an AI Gateway API key, and configures their connection to the gateway. Then select stealth/pixel-canary in your agent's model configuration. AI Gateway provides a unified API for calling models, with built-in usage and cost tracking, budgets for API keys, and routing rules. Try Pixel Canary in the model playground. Read more

## Cursor vs Copilot: Which AI Editor Is Better for Python?

DevFeed: [Cursor vs Copilot: Which AI Editor Is Better for Python?](<https://devfeed.tech/articles/cursor-vs-copilot-which-ai-editor-is-better-for-python-58924.md>)

Original publisher: [Read original article](<https://realpython.com/cursor-vs-copilot/>)

Author: Brian Mutea

Published: 2026-09-23T14:00:00Z

Content type: tutorial

Language: en

Sources: [Real Python](<https://devfeed.tech/sources/real-python.md>)

Topics: [cursor](<https://devfeed.tech/topics/cursor.md>), [GitHub Copilot](<https://devfeed.tech/topics/github-copilot.md>), [AI-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.md>), [Python](<https://devfeed.tech/topics/python.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [debugging](<https://devfeed.tech/topics/debugging.md>), [Code review](<https://devfeed.tech/topics/code-review.md>), [Visual Studio Code](<https://devfeed.tech/topics/visual-studio-code.md>), [Refactoring](<https://devfeed.tech/topics/refactoring.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [ai](<https://devfeed.tech/tags/ai.md>), [code](<https://devfeed.tech/tags/code.md>), [code-review](<https://devfeed.tech/tags/code-review.md>), [comparison](<https://devfeed.tech/tags/comparison.md>), [copilot](<https://devfeed.tech/tags/copilot.md>), [cursor](<https://devfeed.tech/tags/cursor.md>), [debugging](<https://devfeed.tech/tags/debugging.md>), [development](<https://devfeed.tech/tags/development.md>), [python](<https://devfeed.tech/tags/python.md>), [refactoring](<https://devfeed.tech/tags/refactoring.md>), [vs](<https://devfeed.tech/tags/vs.md>), [workflows](<https://devfeed.tech/tags/workflows.md>)

### AI overview

A hands-on comparison of Cursor and GitHub Copilot for Python development. It uses the same Markdown note manager project to examine agent workflows, code completion, debugging, multi-file refactoring, code review, and project conventions.

### Source excerpt

Compare Cursor vs GitHub Copilot by building a Python project, testing agent workflows, debugging code, and evaluating AI-assisted development.

## Postmortem: Why a Markdown-to-HTML CLI Script Failed on Complex Email Layouts

DevFeed: [Postmortem: Why a Markdown-to-HTML CLI Script Failed on Complex Email Layouts](<https://devfeed.tech/articles/the-500-cli-why-version-1-0-was-a-disaster-and-how-procrastination-almost-killed-it-58367.md>)

Original publisher: [Read original article](<https://hackernoon.com/the-$500-cli-why-version-10-was-a-disaster-and-how-procrastination-almost-killed-it?source=rss>)

Author: Arthur

Published: 2026-09-22T19:00:03Z

Content type: article

Language: en

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

Topics: [Command-line interface](<https://devfeed.tech/topics/cli.md>), [Parser](<https://devfeed.tech/topics/parser.md>), [Refactoring](<https://devfeed.tech/topics/refactoring.md>), [Code](<https://devfeed.tech/topics/code.md>), [Markdown](<https://devfeed.tech/topics/markdown.md>), [Script](<https://devfeed.tech/topics/script.md>), [HTML](<https://devfeed.tech/topics/html.md>), [version](<https://devfeed.tech/topics/version.md>), [CSS](<https://devfeed.tech/topics/css.md>), [Node.js](<https://devfeed.tech/topics/node-js.md>)

Tags: [bug](<https://devfeed.tech/tags/bug.md>), [cli](<https://devfeed.tech/tags/cli.md>), [code](<https://devfeed.tech/tags/code.md>), [coding](<https://devfeed.tech/tags/coding.md>), [css](<https://devfeed.tech/tags/css.md>), [dev](<https://devfeed.tech/tags/dev.md>), [email-marketing](<https://devfeed.tech/tags/email-marketing.md>), [github](<https://devfeed.tech/tags/github.md>), [hackernoon-top-story](<https://devfeed.tech/tags/hackernoon-top-story.md>), [html](<https://devfeed.tech/tags/html.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [js](<https://devfeed.tech/tags/js.md>), [node](<https://devfeed.tech/tags/node.md>), [node-js](<https://devfeed.tech/tags/node-js.md>), [project-management](<https://devfeed.tech/tags/project-management.md>), [scripts](<https://devfeed.tech/tags/scripts.md>), [software-development](<https://devfeed.tech/tags/software-development.md>), [startup](<https://devfeed.tech/tags/startup.md>), [version](<https://devfeed.tech/tags/version.md>)

### AI overview

A postmortem of a CLI tool that converted Markdown into HTML for email newsletters. The project struggled because standard Markdown could not represent custom structural blocks, while regex-based parsing failed on edge cases and generated broken HTML. The author also describes procrastination and repeated quick fixes as contributors to the tool's problems.

### Source excerpt

We spent money on student dev hours plus dozens of my own unpaid hours wrestling with Node.js scripts. But it was not a waste of time or money.

## How AI Coding Agents Increase Developer Output--and Can Reduce Work Awareness

DevFeed: [How AI Coding Agents Increase Developer Output--and Can Reduce Work Awareness](<https://devfeed.tech/articles/ai-made-me-5x-faster-it-also-made-me-5x-worse-at-my-job-56875.md>)

Original publisher: [Read original article](<https://towardsdatascience.com/ai-made-me-5x-faster-it-also-made-me-5x-worse-at-my-job/>)

Author: Gursimar Singh

Published: 2026-09-19T13:00:01Z

Content type: opinion

Language: en

Sources: [Towards Data Science](<https://devfeed.tech/sources/towards-data-science.md>)

Topics: [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [agentic-coding](<https://devfeed.tech/topics/agentic-coding.md>), [AI Agent](<https://devfeed.tech/topics/ai-agent.md>), [Code](<https://devfeed.tech/topics/code.md>), [Pull Request](<https://devfeed.tech/topics/pull-request.md>), [Refactoring](<https://devfeed.tech/topics/refactoring.md>), [migration](<https://devfeed.tech/topics/migration.md>)

Tags: [agentic-ai](<https://devfeed.tech/tags/agentic-ai.md>), [agentic-coding](<https://devfeed.tech/tags/agentic-coding.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-adoption](<https://devfeed.tech/tags/ai-adoption.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [ai-coding](<https://devfeed.tech/tags/ai-coding.md>), [code](<https://devfeed.tech/tags/code.md>), [developers](<https://devfeed.tech/tags/developers.md>), [generative-ai](<https://devfeed.tech/tags/generative-ai.md>), [migration](<https://devfeed.tech/tags/migration.md>), [productivity](<https://devfeed.tech/tags/productivity.md>), [progamming](<https://devfeed.tech/tags/progamming.md>), [pull-request](<https://devfeed.tech/tags/pull-request.md>), [refactoring](<https://devfeed.tech/tags/refactoring.md>)

### AI overview

The author argues that AI coding agents can substantially increase developer speed, especially for boilerplate and greenfield work, but that running multiple agents and taking on more tasks can reduce awareness of ongoing work and its purpose. The article reflects on the costs of this pattern and what developers can do differently.

### Source excerpt

One near miss, four months of running agents, and the question almost nobody is asking: what are you supposed to do while the AI writes the code? The post AI Made Me 5x Faster. It Also Made Me 5x Worse at My Job. appeared first on Towards Data Science.

## Code Style and Quality Guide -- Pull Requests & Changes

DevFeed: [Code Style and Quality Guide -- Pull Requests & Changes](<https://devfeed.tech/articles/code-style-and-quality-guide-pull-requests-changes-48567.md>)

Original publisher: [Read original article](<https://flink.apache.org/how-to-contribute/code-style-and-quality-pull-requests/>)

Published: 2026-09-18T15:54:07.612713Z

Content type: tutorial

Language: en

Sources: [Apache Flink](<https://devfeed.tech/sources/apache-flink-stateful-computations-over-data-streams-on-apache-flink.md>)

Topics: [Pull Request](<https://devfeed.tech/topics/pull-request.md>), [Code quality](<https://devfeed.tech/topics/code-quality.md>), [Code review](<https://devfeed.tech/topics/code-review.md>), [Refactoring](<https://devfeed.tech/topics/refactoring.md>), [Java](<https://devfeed.tech/topics/java.md>), [Scala](<https://devfeed.tech/topics/scala.md>)

Tags: [code-quality](<https://devfeed.tech/tags/code-quality.md>), [guide](<https://devfeed.tech/tags/guide.md>), [java-language](<https://devfeed.tech/tags/java-language.md>), [pull-requests](<https://devfeed.tech/tags/pull-requests.md>), [quality](<https://devfeed.tech/tags/quality.md>), [refactoring](<https://devfeed.tech/tags/refactoring.md>), [review](<https://devfeed.tech/tags/review.md>), [scala](<https://devfeed.tech/tags/scala.md>)

### AI overview

A guide for contributors on preparing pull requests for faster, more thorough review. It covers issue naming, pull request descriptions, code quality, and separating refactoring, cleanup, and core changes.

### Source excerpt

Code Style and Quality Guide -- Pull Requests & Changes # Preamble # Pull Requests & Changes # Common Coding Guide # Java Language Guide # Scala Language Guide # Components Guide # Formatting Guide # Rationale: We ask contributors to put in a little bit of extra effort to bring pull requests into a state that they can be more easily and more thoroughly reviewed. This helps the community in many ways:

## Agentic Development Makes Legacy Refactoring More Affordable

DevFeed: [Agentic Development Makes Legacy Refactoring More Affordable](<https://devfeed.tech/articles/the-refactor-you-could-never-afford-55227.md>)

Original publisher: [Read original article](<https://www.sonarsource.com/blog/the-refactor-you-could-never-afford/>)

Author: Brooks Naylor

Published: 2026-09-18T13:00:00Z

Content type: opinion

Language: en

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

Topics: [Refactoring](<https://devfeed.tech/topics/refactoring.md>), [agentic-coding](<https://devfeed.tech/topics/agentic-coding.md>), [legacy systems](<https://devfeed.tech/topics/legacy-systems.md>), [software-development](<https://devfeed.tech/topics/software-development.md>), [version-control](<https://devfeed.tech/topics/version-control.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [agentic-development](<https://devfeed.tech/tags/agentic-development.md>), [code-verification](<https://devfeed.tech/tags/code-verification.md>), [development](<https://devfeed.tech/tags/development.md>), [legacy](<https://devfeed.tech/tags/legacy.md>), [refactor](<https://devfeed.tech/tags/refactor.md>), [refactoring](<https://devfeed.tech/tags/refactoring.md>), [sonarqube](<https://devfeed.tech/tags/sonarqube.md>), [technical-debt](<https://devfeed.tech/tags/technical-debt.md>), [version-control](<https://devfeed.tech/tags/version-control.md>)

### AI overview

The article explains how AI agents can map legacy architecture, generate automated test safety nets, and support large refactors. It emphasizes version control, human judgment, and independent verification before code changes reach production.

### Source excerpt

See how agentic development makes legacy refactoring more affordable while independent code verification keeps fast experiments safe.

## How to Migrate a Legacy Monolith Incrementally Without a Big-Bang Rewrite

DevFeed: [How to Migrate a Legacy Monolith Incrementally Without a Big-Bang Rewrite](<https://devfeed.tech/articles/how-to-migrate-a-legacy-monolith-incrementally-without-a-big-bang-rewrite-42754.md>)

Original publisher: [Read original article](<https://www.freecodecamp.org/news/migrate-legacy-monolith-incrementally/>)

Author: Hugo Teijiz

Published: 2026-09-17T23:27:03Z

Content type: tutorial

Language: en

Sources: [Free Code Camp](<https://devfeed.tech/sources/freecodecamp-programming-tutorials-python-javascript-git-more.md>)

Topics: [Legacy Modernization](<https://devfeed.tech/topics/legacy-modernization.md>), [migration](<https://devfeed.tech/topics/migration.md>), [Refactoring](<https://devfeed.tech/topics/refactoring.md>), [Software Testing](<https://devfeed.tech/topics/software-testing.md>), [Integration testing](<https://devfeed.tech/topics/integration-testing.md>), [observability](<https://devfeed.tech/topics/observability.md>), [Routing (disambiguation)](<https://devfeed.tech/topics/routing.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>), [TypeScript](<https://devfeed.tech/topics/typescript.md>), [API](<https://devfeed.tech/topics/api.md>), [service](<https://devfeed.tech/topics/service.md>), [Dependency injection](<https://devfeed.tech/topics/dependency-injection.md>)

Tags: [artificial-intelligence](<https://devfeed.tech/tags/artificial-intelligence.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [incremental](<https://devfeed.tech/tags/incremental.md>), [integration-testing](<https://devfeed.tech/tags/integration-testing.md>), [legacy](<https://devfeed.tech/tags/legacy.md>), [legacy-code](<https://devfeed.tech/tags/legacy-code.md>), [migrate](<https://devfeed.tech/tags/migrate.md>), [migration](<https://devfeed.tech/tags/migration.md>), [monolith](<https://devfeed.tech/tags/monolith.md>), [refactoring](<https://devfeed.tech/tags/refactoring.md>), [rewrite](<https://devfeed.tech/tags/rewrite.md>), [routing](<https://devfeed.tech/tags/routing.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>), [transactions](<https://devfeed.tech/tags/transactions.md>)

### AI overview

A tutorial on migrating a legacy monolith incrementally by moving one business capability at a time. It covers characterization tests, boundaries between legacy and new code, parallel implementations, progressive traffic, observability, rollback paths, data ownership, and removing migrated behavior.

### Source excerpt

Large legacy migrations often fail long before the final cutover. The failure usually starts when the migration is framed as a single event. Move the application. Move the database. Move all the users

## Jemalloc 5.4 Released With Portability Improvements, Code Cleanups

DevFeed: [Jemalloc 5.4 Released With Portability Improvements, Code Cleanups](<https://devfeed.tech/articles/jemalloc-5-4-released-with-portability-improvements-code-cleanups-42694.md>)

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

Author: Michael Larabel

Published: 2026-09-17T22:37:11Z

Content type: release

Language: en

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

Topics: [Code](<https://devfeed.tech/topics/code.md>), [Refactoring](<https://devfeed.tech/topics/refactoring.md>), [test-coverage](<https://devfeed.tech/topics/test-coverage.md>), [bug](<https://devfeed.tech/topics/bug.md>), [cpu](<https://devfeed.tech/topics/cpu.md>), [gcc](<https://devfeed.tech/topics/gcc.md>), [configuration](<https://devfeed.tech/topics/configuration.md>)

Tags: [bug](<https://devfeed.tech/tags/bug.md>), [code](<https://devfeed.tech/tags/code.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [desktop-linux](<https://devfeed.tech/tags/desktop-linux.md>), [error-handling](<https://devfeed.tech/tags/error-handling.md>), [gcc](<https://devfeed.tech/tags/gcc.md>), [improvements](<https://devfeed.tech/tags/improvements.md>), [linux-benchmarking](<https://devfeed.tech/tags/linux-benchmarking.md>), [linux-hardware-benchmarks](<https://devfeed.tech/tags/linux-hardware-benchmarks.md>), [linux-hardware-reviews](<https://devfeed.tech/tags/linux-hardware-reviews.md>), [linux-how-to](<https://devfeed.tech/tags/linux-how-to.md>), [linux-performance](<https://devfeed.tech/tags/linux-performance.md>), [linux-server-benchmarks](<https://devfeed.tech/tags/linux-server-benchmarks.md>), [open-source-graphics](<https://devfeed.tech/tags/open-source-graphics.md>), [phoronix](<https://devfeed.tech/tags/phoronix.md>), [phoronix-test-suite](<https://devfeed.tech/tags/phoronix-test-suite.md>), [process](<https://devfeed.tech/tags/process.md>), [profiling](<https://devfeed.tech/tags/profiling.md>), [refactoring](<https://devfeed.tech/tags/refactoring.md>), [synchronization](<https://devfeed.tech/tags/synchronization.md>), [test-coverage](<https://devfeed.tech/tags/test-coverage.md>), [thread](<https://devfeed.tech/tags/thread.md>), [ubuntu-benchmarks](<https://devfeed.tech/tags/ubuntu-benchmarks.md>), [ubuntu-hardware](<https://devfeed.tech/tags/ubuntu-hardware.md>), [yield](<https://devfeed.tech/tags/yield.md>)

### AI overview

Jemalloc 5.4 is released with portability improvements, code refactoring, bug fixes, expanded test coverage, new allocation features, optimizations, and GCC 16 warning fixes. The release adds an operating-system abstraction layer for platform-dependent operations.

### Source excerpt

Earlier this year Meta announced a renewed investment into the jemalloc memory allocator that's been popular for server and HPC use among various desktop use-cases too. After stagnating a bit in recent years, Jemalloc has been off to seeing new developments since Meta's announcement and out today is Jemalloc 5.4 as the latest step forward...

## Slicker: A Tool for Moving Things in Python

DevFeed: [Slicker: A Tool for Moving Things in Python](<https://devfeed.tech/articles/slicker-a-tool-for-moving-things-in-python-27406.md>)

Original publisher: [Read original article](<http://engineering.khanacademy.org/posts/slicker.htm>)

Author: Khan Academy

Published: 2018-04-02T22:00:00Z

Content type: article

Language: en

Sources: [Khan Academy](<https://devfeed.tech/sources/khan-academy.md>)

Topics: [Python](<https://devfeed.tech/topics/python.md>), [Refactoring](<https://devfeed.tech/topics/refactoring.md>), [Tool](<https://devfeed.tech/topics/tool.md>), [PyCharm](<https://devfeed.tech/topics/pycharm.md>)

Tags: [bug](<https://devfeed.tech/tags/bug.md>), [code](<https://devfeed.tech/tags/code.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [news](<https://devfeed.tech/tags/news.md>), [pycharm](<https://devfeed.tech/tags/pycharm.md>), [python](<https://devfeed.tech/tags/python.md>), [refactoring](<https://devfeed.tech/tags/refactoring.md>), [tool](<https://devfeed.tech/tags/tool.md>)

### AI overview

This article explains why Khan Academy built Slicker, a tool for moving thousands of Python files, classes, and functions while updating references and imports. It also describes limitations the authors encountered with PyCharm's refactoring tools.

### Source excerpt

By Ben Kraft Craig talked last post about our project to reorganize our whole Python codebase. This entails ... Read more

## C++ in the Age of AI: Visual Studio at CppCon 2026

DevFeed: [C++ in the Age of AI: Visual Studio at CppCon 2026](<https://devfeed.tech/articles/c-in-the-age-of-ai-visual-studio-at-cppcon-2026-21637.md>)

Original publisher: [Read original article](<https://devblogs.microsoft.com/cppblog/c-in-the-age-of-ai-visual-studio-at-cppcon-2026/>)

Author: Augustin Popa

Published: 2026-09-14T19:34:43Z

Content type: article

Language: en

Sources: [C++ Team Blog](<https://devfeed.tech/sources/c-team-blog.md>)

Topics: [C++](<https://devfeed.tech/topics/c-plus-plus.md>), [Visual Studio](<https://devfeed.tech/topics/visual-studio.md>), [GitHub Copilot](<https://devfeed.tech/topics/github-copilot.md>), [build performance](<https://devfeed.tech/topics/build-performance.md>), [MSVC](<https://devfeed.tech/topics/msvc.md>), [debugging](<https://devfeed.tech/topics/debugging.md>), [Optimization](<https://devfeed.tech/topics/optimization.md>), [Refactoring](<https://devfeed.tech/topics/refactoring.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [build-optimization](<https://devfeed.tech/tags/build-optimization.md>), [build-performance](<https://devfeed.tech/tags/build-performance.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [copilot](<https://devfeed.tech/tags/copilot.md>), [cppcon](<https://devfeed.tech/tags/cppcon.md>), [debugging](<https://devfeed.tech/tags/debugging.md>), [github-copilot](<https://devfeed.tech/tags/github-copilot.md>), [msvc](<https://devfeed.tech/tags/msvc.md>), [visual-studio](<https://devfeed.tech/tags/visual-studio.md>), [visual-studio-2026](<https://devfeed.tech/tags/visual-studio-2026.md>)

### AI overview

This companion reading guide covers how Visual Studio 2026 is evolving C++ development with improved code navigation, build and runtime performance, language feature support, debugging, modernization, refactoring, and AI-assisted workflows using GitHub Copilot.

### Source excerpt

At CppCon 2026, we shared how Visual Studio is evolving to help you work more effectively with large C++ codebases, improve build and runtime performance, adopt the latest language features, and incorporate AI into your existing workflows. This post is a companion reading guide for our session, C++ in the Age of AI: How Visual [...] The post C++ in the Age of AI: Visual Studio at CppCon 2026 appeared first on C++ Team Blog.

## Intel Thermald 2.5.13 Restores Accidentally Deleted Wildcat Lake Support

DevFeed: [Intel Thermald 2.5.13 Restores Accidentally Deleted Wildcat Lake Support](<https://devfeed.tech/articles/intel-thermald-2-5-13-restores-accidentally-deleted-wildcat-lake-support-12412.md>)

Original publisher: [Read original article](<https://www.phoronix.com/news/Intel-Thermald-2.5.13>)

Author: Michael Larabel

Published: 2026-09-11T10:01:22Z

Content type: news

Language: en

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

Topics: [intel](<https://devfeed.tech/topics/intel.md>), [Monitoring](<https://devfeed.tech/topics/monitoring.md>), [Hardware](<https://devfeed.tech/topics/hardware.md>), [Linux](<https://devfeed.tech/topics/linux.md>), [Refactoring](<https://devfeed.tech/topics/refactoring.md>), [Arm](<https://devfeed.tech/topics/arm.md>)

Tags: [arm](<https://devfeed.tech/tags/arm.md>), [code](<https://devfeed.tech/tags/code.md>), [desktop-linux](<https://devfeed.tech/tags/desktop-linux.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [intel](<https://devfeed.tech/tags/intel.md>), [linux](<https://devfeed.tech/tags/linux.md>), [linux-benchmarking](<https://devfeed.tech/tags/linux-benchmarking.md>), [linux-hardware-benchmarks](<https://devfeed.tech/tags/linux-hardware-benchmarks.md>), [linux-hardware-reviews](<https://devfeed.tech/tags/linux-hardware-reviews.md>), [linux-how-to](<https://devfeed.tech/tags/linux-how-to.md>), [linux-performance](<https://devfeed.tech/tags/linux-performance.md>), [linux-server-benchmarks](<https://devfeed.tech/tags/linux-server-benchmarks.md>), [monitoring](<https://devfeed.tech/tags/monitoring.md>), [open-source-graphics](<https://devfeed.tech/tags/open-source-graphics.md>), [phoronix](<https://devfeed.tech/tags/phoronix.md>), [phoronix-test-suite](<https://devfeed.tech/tags/phoronix-test-suite.md>), [refactoring](<https://devfeed.tech/tags/refactoring.md>), [release](<https://devfeed.tech/tags/release.md>), [ubuntu-benchmarks](<https://devfeed.tech/tags/ubuntu-benchmarks.md>), [ubuntu-hardware](<https://devfeed.tech/tags/ubuntu-hardware.md>), [update](<https://devfeed.tech/tags/update.md>), [wildcat-lake](<https://devfeed.tech/tags/wildcat-lake.md>)

### AI overview

Intel Thermald 2.5.13 restores support for Intel's Wildcat Lake platform after it was accidentally removed during refactoring in version 2.5.12. The release also follows recent work to extend Thermald toward Qualcomm/ARM hardware.

### Source excerpt

Intel's Thermald released on Thursday as the newest update to this daemon for thermal monitoring on Intel hardware that was also recently extended for beginning to support Qualcomm/ARM hardware too. The main change with Thermald 2.5.13 is adding back Intel Wildcat Lake platform support after it was accidentally removed in the prior release...

[Next page](<https://devfeed.tech/topics/refactoring.md?cursor=WyIyMDI2LTA5LTExVDEwOjAxOjIyKzAwOjAwIiwgIjI3ZGM5YzgyLTQ4ZDEtNGJkZi04ZDNkLTg4ZDQ5MDhmYTBhOCJd>)