A three-level taxonomy inspired by autonomous driving that distinguishes degrees of autonomy along a roadmap from today’s AI-assisted development workflows to fully autonomous software development in which AI systems autonomously identify demands and design, implement, verify, and maintain software without human oversight is introduced.
The growing adoption of Large Language Models (LLMs) in Software Engineering has reinforced the expectation that coding activities can be largely automated. However, this perception may represent yet another historical search for a solution capable of eliminating the inherent challenges of software development. This article discusses the transition from a code-centered paradigm to Specification-Driven Development. We argue that artificial intelligence reduces some of the effort associated with writing source code, but it does not eliminate the complexity of developing professional software systems. Instead, it shifts this complexity toward domain understanding, requirements elicitation, specification development, validation, maintenance, and software evolution. Building on this perspective, we discuss the renewed centrality of Requirements Engineering, considering its implications for productivity and software quality, as well as risks associated with automation bias, ambiguity propagation, Specification Overfitting, and the accumulation of Specification Debt. Finally, we propose the Specification Paradox: the more capable artificial intelligence systems become at automatically generating software, the greater the dependence on correct, complete, verifiable, and explainable human-produced specifications. We conclude that the future of Software Engineering will depend not only on machines'ability to generate code, but also on humans'ability to correctly specify, evaluate, and evolve what is intended to be built.
The rapid advancement of generative artificial intelligence has begun to fundamentally reshape software development practices, particularly within mobile engineering environments characterized by high complexity and rapid iteration cycles. While early applications of artificial intelligence in development have largely focused on isolated tasks such as code completion or automated testing, a broader transformation is emerging in which AI systems participate directly in the end-to-end development workflow. This study introduces the concept of prompt-to-code engineering as a system-level paradigm that integrates artificial intelligence into the core structure of mobile development processes. Rather than treating AI as a supplementary tool, the proposed framework conceptualizes it as an active computational agent capable of interpreting developer intent and generating executable code artifacts. This shift redefines the role of human developers, transitioning from direct implementation toward specification, orchestration, and validation. The paper presents a layered architecture for AI-integrated development systems, encompassing prompt formulation, semantic interpretation, code generation, and validation mechanisms. It further examines the dynamics of human–AI interaction, highlighting the importance of trust calibration, control boundaries, and iterative refinement in achieving reliable outcomes. A key contribution of this work lies in its analysis of productivity and cognitive transformation. By reducing repetitive implementation tasks and compressing development cycles, prompt-to-code systems alter both the efficiency and nature of engineering work. However, these benefits are accompanied by new challenges related to reliability, correctness, and risk management, particularly in the context of probabilistic code generation. The study also explores the organizational implications of AI integration, including shifts in skill requirements, workflow restructuring, and the emergence of hybrid human–AI development models. The findings suggest that the integration of AI at the system level represents not merely an incremental improvement but a fundamental evolution in software engineering methodology. This work contributes to the emerging field of AI-assisted software engineering by providing a structured and theoretically grounded framework for understanding and implementing prompt-to-code systems within mobile development environments.
Yasin Arik· International Journal of Res...· 0 citations
Automating software development is an important aspect of software engineering. Generative Artificial Intelligence (GenAI) Agents that control multiple tools and use feedback with some autonomy to iteratively solve problems are emerging as promising tools for increased software production. To achieve autonomous software maintenance with minimal human involvement, such agents must not only solve human-posed problems but also decide which problems to address. We report our experiences developing a GenAI agent that autonomously formulates, prioritizes, and completes a limited set of code improvement tasks enterprise-wide, and we evaluate this agent from two perspectives: first, developing a methodology to estimate effort savings from such autonomous agents by comparing time spent on agent-introduced tasks and agent maintenance efforts against manual execution; and second, comparing the impact of manual versus agent-driven code improvements on future codebase maintenance. Our results demonstrate significant effort savings, even after accounting for effort in agent development, and a Difference-in-Differences (DiD) analysis found that automated improvements had an effect on the reduction of future maintenance effort that was as strong as or stronger than manual improvements confirming the feasibility of autonomous maintenance. While the relaxed completion and timeliness needs of perfective maintenance make it an ideal candidate for autonomy, a degree of autonomy may be achievable in other areas of software development as well.
Software testing is moving away from rigid, hand-written scripts toward AI systems that can adapt on their own. This review traces how quality engineering has changed, from rule-based automation to self-adjusting test frameworks, and looks at the technology behind Autonomous Quality Agents: Large Language Models (LLMs) that generate code from requirements, Computer Vision that handles visual regression, and Reinforcement Learning that drives exploratory testing. It also examines two ongoing problems: the difficulty of understanding how AI models make decisions, and the extra work needed to keep older, script-based automation running. The review closes with a proposed framework for where autonomous software assurance is headed next. This proposed framework, termed Autonomous Quality Assurance (AQA), is organised around three layers, perception (visual and DOM-based sensing), cognition (LLM-driven reasoning and test generation), and governance (interpretability and verification), intended to give practitioners and researchers a shared structure for locating where a given tool or technique sits today and what would need to mature before autonomous testing can be trusted at industrial scale.
Vanshita Agarwal· International journal for ad...· 0 citations
This study characterize agentic pull requests (PR) in comparison to human generated PRs and to examine how their properties change across different stages of the development lifecycle, offering a more nuanced understanding of their benefits and limitations in real-world practices.
Iren Mazloomzadeh, Mohammad Mehdi Morovati, F. Khomh· 0 citations
This survey aims to clarify the conceptual boundaries of self-evolving coding agents and provide a foundation for designing more adaptive, reliable, and software-aware agentic systems.
H. Zhou, Haichuan Hu, Ye Shang et al.· 0 citations