AI-Assisted Software Engineering

• AI-assisted software engineering is the integration of AI techniques like LLMs and agentic systems to automate tasks across the software development lifecycle.
• It leverages methodologies such as model-driven engineering and compiler-inspired paradigms to enhance code synthesis, testing, and maintenance.
• Key challenges include risk mitigation, explainability, and aligning AI-generated outputs with human intent to ensure robust and safe implementations.

AI-assisted software engineering (AI-ASE) refers to the systematic integration of artificial intelligence—particularly LLMs, deep learning, agentic architectures, and related machine learning paradigms—across the entire software engineering (SE) lifecycle. This encompasses a spectrum from code generation and review, automated testing and repair, requirements analysis, model-driven development, through to deployment, runtime monitoring, and self-evolution of software artifacts. The field spans both research and industrial practice, addressing not only productivity and efficiency, but also safety, trust, explainability, and socio-technical transformation in SE organizations. AI-ASE includes both stateless LLM-driven assistants and multi-agent, orchestrated AI “team members” capable of reasoning, tool use, and mixed-initiative workflows.

1. Principal Taxonomies and Frameworks

A converging theme in the literature is the need for principled classification of AI-ASE activities. The AI-SEAL taxonomy specifies three orthogonal axes: Point of Application (Process, Product, Runtime), AI “Tribe” (e.g., Symbolist, Connectionist, Evolutionary, Bayesian, Analogizer), and Level of Automation (LA, 1–10 scale) (Feldt et al., 2018). For practical mapping of tools:

Axis	Categories	Example Tool/Task
Process	Test analytics, clustering	k-means test clustering
Product	Code gen, repair	GenProg automated patching
Runtime	Self-tuning, adaptation	RL-based DB index selection

Tools such as Copilot (Connectionist, Product, LA ≈ 3–5) and agentic frameworks (e.g., USEagent (Applis et al., 17 Jun 2025)) can be classified along these axes to guide risk mitigation: lower LA and Process-level applications are low risk; increased autonomy at Product/Runtime mandates robust guardrails and human oversight.

The AI4SE taxonomy (Schieferdecker, 2024) adds a three-dimensional classification: Goal (understanding/generation/improvement), Lifecycle Phase (requirements/architecture/design/etc.), and Level of autonomy (recommend/pre-select/partial/full automate). Most state-of-the-art tools reside at (generation, construction, recommend), but agentic systems increasingly reach "full automate” with code and test synthesis and partial autonomy in system-level design.

2. Core AI Techniques and Architectures

Contemporary AI-ASE is dominated by large-scale connectionist models (Transformers), typically fine-tuned on big code corpora such as GitHub repositories. Foundational models (e.g., GPT-4, Llama 3, Prize LLM (Sahai et al., 13 Aug 2025)) serve as zero-shot/few-shot code generators, code reviewers, test writers, and documentation assistants (Qiu et al., 2024, Sergeyuk et al., 2024, Alami et al., 3 Jan 2025).

Recent advances extend to agentic AI, with single or multi-agent orchestrations capable of stateful reasoning, iterative task decomposition, intent inference, and tool invocation. USEagent exemplifies a unified SE agent: a ReAct-style meta-agent executes structured actions (code retrieval, testing, patch editing), maintaining consensus memory and orchestrating submodules for code search, test execution, and patching (Applis et al., 17 Jun 2025). More broadly, “pair modelling” frameworks allow a human and AI to alternately drive modeling and transformation in an MDSE context (Schieferdecker, 2024).

Self-evolving software frameworks combine multi-agent swarms (leader, data manager, code generator, validator) with cross-validation loops and empirical risk minimization, pushing toward human-free continuous evolution of software artifacts (Cai et al., 1 Oct 2025).

3. Human-AI Interaction and Socio-Technical Impacts

AI-ASE fundamentally reconfigures developer roles. The pragmatic process model (Garousi et al., 23 Jul 2025) describes an iterative loop: activity scoping → prompt design → AI generation & inspection → human acceptance, refinement, or fallback. Decision frameworks map quality (Q) and effort saved (E) into quadrant-based rules for accept/inspect/reject actions.

Empirical studies reveal that while LLMs efficiently handle routine coding (boilerplate, test generation, docstrings), higher-value activities (complex logic design, deep bug triage) remain dominated by human expertise due to AI’s limits in context integration and nuanced reasoning (Sergeyuk et al., 2024, Alami et al., 3 Jan 2025). User interviews show that LLM-assisted code reviews yield lower emotional burden and more neutral feedback, but incur higher cognitive load due to verbosity and lack of context; trust in LLM feedback is constrained by perceived depth and project-specific awareness (Alami et al., 3 Jan 2025).

Survey data consistently indicate strong willingness to delegate less-enjoyed tasks (tests, documentation) to AI, but highlight lack of context, inaccuracy, and explainability as dominant barriers to deeper adoption (Sergeyuk et al., 2024).

4. Limitations, Risks, and Safety Frameworks

AI-ASE introduces significant intrinsic risks: synthetic code can inherit vulnerabilities (40% rate observed for AI-generated code), hallucinate APIs/modules, misinterpret under-specified prompts, or act unrecoverably in agentic workflows (e.g., AI-caused data loss) (Navneet et al., 15 Aug 2025). The SAFE-AI Framework encodes safety (guardrails, sandboxing, runtime verification), auditability (risk-aware immutable logs), feedback (HITL, prompt versioning), and explainability (SHAP, attention tracing), assigning risk scores to agent actions based on autonomy, irreversibility, and impact:

$$R(B) = \alpha_{\rm autonomy} + \beta_{\rm irreversibility} + \gamma_{\rm impact}$$

with graded escalation for higher-risk behaviors (suggestive → generative → autonomous → destructive). Regulatory compliance is mapped to the EU AI Act, Canada’s AIDA, and NIST RMF via audit trail, human oversight, and real-time robustness (Navneet et al., 15 Aug 2025, Sahai et al., 13 Aug 2025).

Adversarial red teaming (e.g., Amazon Nova AI Challenge) leverages multi-turn tournaments where attack bots probe for jailbreaks and safe AI assistants are stress-tested via both static analysis (e.g., CodeGuru) and human annotation. Defense relies on lightweight classifiers, reasoning alignment, vulnerability fixers, and iterative SFT/RL alignment—all optimized for joint safety-utility (Sahai et al., 13 Aug 2025).

5. Higher Abstraction, Model-Driven Engineering, and Compiler-Inspired Paradigms

AI-ASE is now converging with MDSE through “big models for model-driven SE” (Schieferdecker, 2024). Here, neural models are trained to attend over not just code tokens, but also model graphs, design artefacts, and requirements. Pair modeling workflow demonstrates up to 30% reduction in modeling time and 40% reduction in inconsistencies, showing that AI can serve as a high-bandwidth observer, navigator, and co-creator of design artifacts.

The Compiler.next architecture embodies the transition to “Software Engineering 3.0”: user intent (requirements, tests, constraints) is compiled via a search-based optimization pipeline (multi-objective genetic algorithms, scenario expansion, semantic caching) into working FMware—DAGs of prompt chains, RAGs, agent plans—which are then fused, executed, and refined against gold/unit-test suites. Multi-objective optimization balances accuracy, latency, and inference cost, while maintaining reproducibility and interoperability across FM and orchestration stacks (Cogo et al., 27 Oct 2025, Hassan et al., 2024).

6. Evaluation, Benchmarks, and Empirical Findings

Relevant experimental protocols increasingly utilize compound benchmarks integrating code repair, test generation, partial fix, and feature development tasks (e.g., USEbench: 1,271 tasks from SWE-bench, SWT-bench, REPOCOD, REPOTEST) (Applis et al., 17 Jun 2025). USEagent achieves a 33.3% overall pass rate (@1), outperforming generalist baselines, but method-level code synthesis and partial-fix tasks remain low-performing (6–8%), exposing the need for improved decomposition and search (Applis et al., 17 Jun 2025).

Compiler.next demonstrates gains of 46–47% in code-generation task accuracy and up to 42% reduction in latency by optimizing both neural and prompt parameters jointly (Cogo et al., 27 Oct 2025). In self-evolving software, cross-execution consistency and minimum Bayes risk selection yield >98% accuracy in code validation for representative scenarios, with effective sublinear scaling as codebases grow (Cai et al., 1 Oct 2025).

AI-augmented agentic workflows tested in production contexts (AutoCodeRover, RepoAudit) achieve repair success on par with the best open baselines, while empirical ablation confirms that lightweight human-in-the-loop substantially increases solution pass rate (e.g., from 24% to 75% in AISD (Zhang et al., 2024)).

7. Outstanding Challenges and Future Directions

Several open problems define the cutting-edge of AI-ASE research:

• Specification Inference and Intent Alignment: Agentic workflows crucially depend on robust, scalable mapping of NL requirements/issues to formal specifications and behavioral contracts, but current methods are limited in search-space management and generalization (Roychoudhury, 24 Aug 2025, Zhang et al., 2024).
• Overfitting and Verification: Agents tend to overfit to minimal coverage; adversarial or mutational test amplification, integration with theorem provers, and formal V&V pipelines remain research frontiers (Applis et al., 17 Jun 2025, Roychoudhury, 24 Aug 2025).
• Explainability and Trust Calibration: Model-agnostic XAI techniques (LIME, LoRMIkA) aid defect localization and mitigation, but are not yet widely deployed; trust remains gated by the AI’s ability to provide user-actionable rationale (Tantithamthavorn et al., 2020).
• Runtime and Autonomy Benchmarks: There is a lack of standardized metrics for hallucination rate, autonomy level, and behavioral explainability in agentic IDEs and compound FMware (Navneet et al., 15 Aug 2025).
• Socio-Technical Protocols: Maturity models, onboarding practices, and hybrid workflows (personalized AI-human feedback pipelines, emotional intelligence in code review) require both technical and organizational innovation (Alami et al., 3 Jan 2025, Garousi et al., 23 Jul 2025).

Ongoing development targets continuous improvement cycles, open-source FMware IR standards, semantic observability, Pareto-front IDE integration, and dynamic safety-utility optimization. Scaling these advances while preserving human understanding and organizational control over critical SE outcomes is the primary agenda for AI-assisted software engineering.