The rapid advancement of LLMs has opened new opportunities in automated software engineering, driving progress in code understanding, agent-based workflows, and productivity tools. However, existing code intelligence systems have largely sidelined the end-users they aim to serve—the developers themselves. Developers exhibit substantial heterogeneity across multiple dimensions: coding style, toolchain preferences, domain-specific expertise, and problem-solving strategies. Failing to account for these individual differences directly compromises both the effectiveness of code intelligence and the likelihood of its adoption. For example, a senior architect and a junior engineer ask: "Describe the authorization module." Without personalized context, the system produces a uniform response—verbose for the expert, incomprehensible for the novice. This gap motivates a fundamental shift: from one-size-fits-all to one-size-fits-one code intelligence. A developer's dynamic in-IDE behaviors—code authoring patterns, navigation pathways, debugging trajectories—implicitly encode a rich representation of their competencies and habits. If captured and interpreted systematically, these signals can enable Personalized Code Intelligence, formalized as: [EQUATION] where P is the developer persona derived from IDE behaviors, injected alongside code context C and instruction ℐ.
Agentic code generation has shown promise in automating and accelerating software development by utilizing Large Language Models (LLMs) to generate, test, and deploy code. For engineers and scientists, such systems have the potential to accelerate the development of applied and scientific workflows while reducing barriers to entry in domains that have yet to fully realize their benefits. However, a key gap remains: existing coding agents primarily focus on code generation and do not address the entire workflow lifecycle, including deployment and sharing. As a result, users develop and stitch modules independently while managing deployment on their own. To address this gap, we propose CURATE - Composition, User-in-the-loop, Reuse, and Automated Task Execution - a novel human-in-the-loop multi-agent system that uses LLM agents to manage and develop composable workflows across their entire lifecycle. A key feature of the system is a catalog that allows for the storage and reuse of modules across workflows. Module catalogs provide a foundation that can be expanded to support FAIR principles by facilitating the sharing and reuse of curated modules and subgraphs. We demonstrate the feasibility of our system with an initial prototype using Claude Opus 4.8, comprising 6 experiments: reproducing and adapting 4 workflows derived from the SeBS-Flow benchmark suite, and automating the development and scaling of a workflow that leverages a complex mechanistic model in environmental engineering used to simulate anaerobic digestion.
Nolan Cutler, Chia-Chen Kuo, Nanda Velugoti et al.· 0 citations
AI agents are becoming a fundamental part of modern software creation, helping developers in generating code, debugging, designing systems, etc. But there is a clear difference between how beginners and experienced software engineers get benefits from these tools. Newbies usually depend on agents for one-time prompts and quick answers, whereas mature users utilize them through well-defined, repeated workflows that raise productivity and consistency. In this article, we discuss this difference and emphasize that getting the full potential does not merely depend on better prompts but on workflows driven by instructions developers create clear and reusable instruction files to direct agent behavior across tasks. When developers stop seeing agents only as chat interfaces but as programmable collaborators, they can produce more reliable and high-quality outputs. We offer in our paper methods like designing modular instructions, narrowing down the context, and iterative refinement loops, as well as a case study illustrating how a team made a code review more efficient and minimized the rework by making agent instructions standard. The results stress that structured forms of interaction rather than sporadic use are the main ways to tap into advanced features. Our paper provides a conceptual model for agent usage at large scale, hands-on advice for the implementation of instruction files in actual settings, and validation that skillful developers can far exceed basic usage by adopting orderly, system-like approaches to agent collaboration.
Madhurima Kommuru, Srujana Pulipaka· International Journal of Mod...· 0 citations
In modern software development, the rapid advancement of Large Language Models (LLMs) has made the end-to-end transformation of Natural Language Requirements (NLRs) into executable repository-level code increasingly feasible. However, existing approaches typically rely on simplified instructions (e.g., single-sentence descriptions), failing to reflect complex software development scenarios. Moreover, they lack explicit requirement traceability mechanisms, making it difficult to precisely align and validate generated code against original requirements. To address these limitations, we propose TraceDev, a multi-agent framework for automated software development grounded in use cases that contain multiple functional points and complex semantics. TraceDev employs five role-specific agents, including a Requirement Refiner, Designer, Developer, Tester, and Validator. Notably, the Validator Agent constructs and maintains a heterogeneous traceability graph that links requirements, design models, and code artifacts for interacting with the preceding four agents. The traceability graph maintains consistency across various artifacts and serves as a structured context for efficient memory management, supporting reliable repository-level code generation. We evaluate TraceDev on two widely used datasets (including 125 use cases) compared with two state-of-the-art approaches. On the ETOUR dataset, TraceDev achieves a success rate of 53.63\%, outperforming baseline approaches by up to 186.63\%. A similar trend is observed on the SMOS dataset, where TraceDev attains a success rate of 56.82\%, exceeding baseline approaches by up to 340.80\%. These results demonstrate the effectiveness of TraceDev in repository-level code generation from requirements.
Mingyu Chen, Yakun Zhang, Zihao Xie et al.· 0 citations
Agentic IDEs are among the most significant innovations in software engineering, aiming to accelerate application development through LLM-based agents that can assist developers during development. However, their evaluation in end-to-end development tasks involving the generation of complete applications remains limited. To fill this gap, we propose a rigorous comparative analysis of three popular agentic IDEs (Copilot, Cursor, and Windsurf) in the generation of five full-stack Web applications from scratch. Results show high maturity in the generation of established patterns, such as CRUD operations and authentication features. In contrast, the generation of less common distributed architectures, such as a task queue architecture, produces significantly more errors. Overall, results show that Agentic IDEs cannot replace developers but shift their role toward building software by orchestrating LLM-based agents through natural-language instructions and iterative refinement. Yet, each agentic IDE shows its peculiarities, although differences are narrow.
Manuel Marceca, Maria Teresa Rossi, Leonardo Mariani· 0 citations
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
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.