Generative AI promises substantial productivity gains, but many initiatives fail. This column argues that outcomes depend on readiness, not technology alone. We examine AI transformation requirements across organizational, individual, and technological dimensions, highlighting why engineering practices, human factors, and strategic clarity determine success.

Software-intensive organizations need effective ways to identify where maintenance and refactoring efforts will yield the greatest practical benefit. Although software analytics such as code health, hotspots, and coupling provide valuable signals, they do not always capture the experienced burden of change that slows software evolution in practice. This paper presents a multi-case industrial study of technical debt friction as a prioritization-oriented concept for identifying where technical debt most strongly affects maintenance and evolution. We investigate how practitioners interpret the concept, whether friction-related analysis aligns with perceived maintenance pain points and refactoring needs, and what broader maintenance and evolution insights friction can provide beyond individual refactoring candidates. To this end, we conducted structured walkthrough sessions with practitioners across multiple industrial cases using analysis artifacts including code health, hotspots, coupling, refactoring targets, and socio-technical views. Our findings show that practitioners generally considered technical debt friction useful for reasoning about maintenance burden, especially when interpreted together with complementary technical and socio-technical views. At the file level, friction often aligned with known problematic areas and, in several cases, with files that later received maintenance attention, although its practical relevance depended strongly on context. In addition, our exploratory project-level analysis suggests that friction distributions may reveal broader maintenance and evolution patterns. These results indicate that technical debt friction is promising as a decision-support concept, but most effective when used with contextual knowledge and supporting evidence.

AI assistants, like GitHub Copilot and Cursor, are transforming software engineering. While several studies highlight productivity improvements, their impact on maintainability requires further investigation. This study investigates whether co-development with AI assistants affects software maintainability, specifically how easily other developers can evolve the resulting source code. We conducted a two-phase, preregistered controlled experiment involving 151 participants, 95

Context: The AI Act marks a new chapter in AI governance, affecting companies around the world seeking to offer their services within the European Union. This study focuses on the comprehensive AI Act requirements set out for high-risk AI systems. Objectives: We explored the perceived compliance challenge for the AI Act’s high-risk requirements and associated contributing factors; the AI Act’s impact on industry in terms of positive and negative side effects; and the sentiment of industry practitioners towards the AI Act’s codes of conduct for the voluntary application of the act’s high-risk AI requirements. Method: A multiple case study encompassing six case companies supplemented by three independent experts with a total of 16 respondents was conducted. Results: A ranking represents the different perceived levels of challenge for each AI Act high-risk requirement. The ranking is led by the following requirements, starting with the most challenging one: (1) data quality and governance (Art 10), (2) accuracy, robustness, and cybersecurity (Art 15), (3) risk and quality management system (Art 9, 17), and (4) transparency (Art 13). Moreover, four contributing factors emerged that impact the perceived compliance challenge: (1) industry and brand values, (2) existing regulatory environment, (3) AI maturity level and proficiency, and (4) company size. We identified several general key factors for the AI Act’s impact on industry and outlined strong arguments both for and against the AI Act voiced by practitioners. The sentiment towards the AI Act’s codes of conduct turned out very positive. Conclusion: This study offers a valuable primary research contribution to software engineering, where the state-of-the-art remains short of compliance-oriented studies with a focus on the operationalization of certain AI Act aspects. Future work is advised to develop artifacts facilitating AI Act operationalization and to validate them with industry partners.

Coding agents powered by Large Language Models (LLMs) are now prominent in software engineering. Previous work has shown that AI tools perform better on high-quality source code that is easy to maintain. In this study, we investigate how the effectiveness of LLM-generated unit tests varies across maintainability levels measured by CodeScene's CodeHealth (CH). We assess test effectiveness using traditional coverage metrics and mutation score across Python, Java, and C++. Moreover, we study how code with different levels of CH translates into input tokens using common industrial tokenizers. Our results suggest that CH provides a weak but consistent signal of LLM-generated test effectiveness and is negatively correlated with input-token count. These findings provide further evidence for a relationship between maintainability and LLM-based software development.

We are entering a hybrid era in which human developers and AI coding agents work in the same codebases. While industry practice has long optimized code for human comprehension, it is increasingly important to ensure that LLMs with different capabilities can edit code reliably. In this study, we investigate the concept of “AI-friendly code” via LLM-based refactoring on a dataset of 5,000 Python files from competitive programming. We find a meaningful association between CodeHealth, a quality metric calibrated for human comprehension, and semantic preservation after AI refactoring. Our findings confirm that human-friendly code is also more compatible with AI tooling. These results suggest that organizations can use CodeHealth to guide where AI interventions are lower risk and where additional human oversight is warranted. Investing in maintainability not only helps humans; it also prepares for large-scale AI adoption.

The Artificial Intelligence (AI) Act is a relatively new regulation set out in the European Union (EU). It lays out various requirements for AI systems that are placed on the market in the EU. This paper provides a critical and differentiated view of its requirements from a software engineering perspective. A detailed analysis of the legal document shows what requirements are set out for different types of AI systems covered by the AI Act. This also includes how the risk classification of AI systems works, how this relates to the applicable requirements, and its interplay with the potential impact of this law. A comparative requirements analysis shows the variance in the extent of requirements coverage between the different types of AI systems as defined by the AI Act, with a special focus on interpretability and explainability. We conclude that the AI Act marks a big leap in terms of general system transparency because of some transparency requirements with a wide-reaching scope of affected AI systems. At the same time, it is acknowledged that its most comprehensive and severe requirements, including the ones related to explainability and interpretability, only apply to a more narrow pre-defined set of AI systems. Upcoming harmonized standards are expected to clarify existing ambiguities and significantly influence the act’s impact and complexity of operationalization.

In the software industry, the drive to add new features often overshadows the need to improve existing code. Large Language Models (LLMs) offer a new approach to improving codebases at an unprecedented scale through AI-assisted refactoring. However, LLMs come with inherent risks such as braking changes and the introduction of security vulnerabilities. We advocate for encapsulating the interaction with the models in IDEs and validating refactoring attempts using trustworthy safeguards. However, equally important for the uptake of AI refactoring is research on trust development. In this position paper, we position our future work based on established models from research on human factors in automation. We outline action research within CodeScene on development of 1) novel LLM safeguards and 2) user interaction that conveys an appropriate level of trust. The industry collaboration enables large-scale repository analysis and A/B testing to continuously guide the design of our research interventions.

The remarkable advances in AI and Large Language Models (LLMs) have enabled machines to write code, accelerating the growth of software systems. However, the bottleneck in software development is not writing code but understanding it; program understanding is the dominant activity, consuming approximately 70% of developers' time. This implies that improving existing code to make it easier to understand has a high payoff and - in the age of AI-assisted coding - is an essential activity to ensure that a limited pool of developers can keep up with ever-growing codebases. This paper introduces Augmented Code Engineering (ACE), a tool that automates code improvements using validated LLM output. Developed through a data-driven approach, ACE provides reliable refactoring suggestions by considering both objective code quality improvements and program correctness. Early feedback from users suggests that AI-enabled refactoring helps mitigate code-level technical debt that otherwise rarely gets acted upon.

DevOps has significantly improved the software development life-cycle by enabling fast, automated, and continuous integration and deployment (CI/CD). However, its application to Cyber-Physical Systems (CPS) presents unique challenges that require rethinking of traditional practices. DevOps in CPS becomes even more challenging when we consider sustainability, which is becoming increasingly important in all parts of society. In this position paper, we suggest that sustainability, though often overlooked, needs more attention in DevOps for CPS. Through insights gathered from a multi-industry workshop, we identify relevant sustainability goals, such as optimizing resource usage, and key barriers to sustainability in DevOps for CPS, such as difficulties in measuring sustainability improvements. To overcome these challenges, we propose strategies, such as using tools for reproducible builds, but also incorporation of sustainability goals into the organization and possibly in alignment with financial goals. We further see a need for more guidelines and frameworks specifically targeting sustainability.

Software maintainability is essential for long-term success in the software industry. Despite widespread evidence of the high costs associated with poor maintainability, market pressure drives many organizations to prioritize short-term releases. This focus leads to accumulating technical debt worldwide. In this preliminary work, we propose maintainability gamification through anonymous leaderboards to encourage organizations to maintain a sustained focus on code quality. Our approach envisions benchmarking to foster motivation and urgency across companies by highlighting thresholds for leaders and laggards. To initiate this concept, we analyze a sample of over 1,000 proprietary projects using CodeHealth scores. By examining the distribution of these scores across various dimensions, we assess the feasibility of creating effective leaderboards. Findings from this study offer valuable insights for future design activities in maintainability gamification.

The use of static program analysis tools can be highly beneficial in software development, but usage is hindered by usability issues. One method of better understanding these issues is to gather user feedback, but it is difficult for developers to invest effort in giving feedback. In this paper, we investigate whether gamification can increase user engagement in feedback collection for static analysis tools. We conducted a mixed-method study at a large software company, with initial user research, design of a feedback system with context-sensitive gamification, deployment of the system to 900 developers over 14 days in an experiment with randomized assignment, and a final collection of qualitative user input. We found that user engagement increased for the gamification group in terms of the amount of feedback (2.47 times more feedback), but the difference is not statistically significant, and participants also expressed a mix of enthusiasm and skepticism in our follow-up interviews.

We explore vibe coding as a rapid prototyping approach powered by generative AI. We discuss how it lowers the barrier to creating high-fidelity prototypes, enabling nontechnical users to build apps, and examine its implications for communication, validation, and iterative software design.

Held in sunny Barcelona, REFSQ 2025 brought together researchers and practitioners around the theme of social responsibility in requirements engineering. As diversity, equity, and inclusion (DEI) efforts are currently under threat, this year’s conference theme felt more relevant than ever. This column summarizes a panel discussion on responsibility. Given the mediator role of our field, what other software engineering discipline could be a better fit for responsible engineering? And this will just keep getting more important as the influence of technology on society increases. Happy reading!—Markus Borg

Maintainable source code is essential for sustainable development. Yet, many studies show that maintainability often receives less attention than it deserves. We argue that requirements engineering can help close this gap by fostering discussions and setting appropriate targets in a responsible manner. In this preliminary work, we explore industry practices related to requirements engineering for maintainability. Our findings confirm previous studies: maintainability remains a second-class quality concern. Explicit requirements often make sweeping references to coding conventions. Tools providing maintainability proxies are common but typically only used in implicit requirements related to engineering practices. To address this, we propose QUPER-MAn, a maintainability adaption of the QUPER model, originally developed for performance requirements. Developed using a design science approach, QUPERMAn integrates maintainability benchmarks and supports target setting. We posit that it can shift maintainability from an overlooked development consequence to an actively managed goal driven by informed and responsible engineering decisions.

Context: AI technologies are increasingly embedded in products and software engineering processes of industrial IoT, autonomous systems, and cyber-physical systems. It is therefore essential to ensure alignment with safety, reliability, and ethical standards. However, practical software engineering methods for managing misalignment risks remain underdeveloped. Objective: This study aims to explore industry awareness of misalignment risks and current practices for monitoring them within real-world software engineering contexts. Method: We conducted seven interviews with industry professionals to examine perceptions of misalignment risks, gather insights into existing practices, and understand approaches to alignment across various industrial settings. Three recently proposed taxonomies guided our discussions: one on ethical guidelines for trustworthy AI published by the EU, another summarizing identified AI risks, and a third addressing “double-edged components” (aspects of AI systems that can simultaneously yield positive and negative effects.) Results: Our analysis identified common misalignment risks across these settings and revealed limited use of dedicated testing or monitoring for AI alignment. Most organizations rely on general oversight rather than specialized tools. Conclusion: These findings highlight the need to develop tailored governance practices for alignment in industrial software engineering settings.

This paper presents an extended version of Deeper, a search-based simulation-integrated test solution that generates failure-revealing test scenarios for testing a deep neural network-based lane-keeping system. In the newly proposed version, we utilize a new set of bio-inspired search algorithms, genetic algorithm (GA), ( μ + λ ) and ( μ , λ ) evolution strategies (ES), and particle swarm optimization (PSO), that leverage a quality population seed and domain-specific crossover and mutation operations tailored for the presentation model used for modeling the test scenarios. In order to demonstrate the capabilities of the new test generators within Deeper, we carry out an empirical evaluation and comparison with regard to the results of five participating tools in the cyber-physical systems testing competition at SBST 2021. Our evaluation shows the newly proposed test generators in Deeper not only represent a considerable improvement on the previous version but also prove to be effective and efficient in provoking a considerable number of diverse failure-revealing test scenarios for testing an ML-driven lane-keeping system. They can trigger several failures while promoting test scenario diversity, under a limited test time budget, high target failure severity, and strict speed limit constraints.

In this final issue of the year, we mark a milestone: IEEE Software’s 40th anniversary—a ruby jubilee! While this column still awaits the silver achievement badge (25 years)—Suzanne Robertsson founded it in the early millennium—I’m pleased to present a discussion with two seasoned professors of requirements engineering. They will share their personal reflections on the discipline over the past four decades. I’m particularly pleased to feature a retrospective by the new retiree, Prof. Sandahl. Naturally, we conclude with an outlook on what is to come. Long live the new quadragenarian!—Markus Borg

[Background/Context] AI assistants like GitHub Copilot are transforming software engineering; several studies have highlighted productivity improvements. However, their impact on code quality, particularly in terms of maintainability, requires further investigation. [Objective/Aim] This study aims to examine the influence of AI assistants on software maintainability, specifically assessing how these tools affect the ability of developers to evolve code. [Method] We will conduct a two-phased controlled experiment involving professional developers. In Phase 1, developers will add a new feature to a Java project, with or without the aid of an AI assistant. Phase 2, a randomized controlled trial, will involve a different set of developers evolving random Phase 1 projects - working without AI assistants. We will employ Bayesian analysis to evaluate differences in completion time, perceived productivity, code quality, and test coverage.