AI-Native Software Engineering

• AI-native software engineering is a paradigm that treats AI as a first-class participant, shifting focus from code-centric development to intent-first orchestration.
• It defines key abstractions around human intent, agent interfaces, and invocable capabilities, enabling automated composition and dynamic system validation.
• The approach reconfigures the software lifecycle by reallocating human roles towards oversight and requirements while AI agents handle generation, testing, and deployment.

AI-native software engineering is a family of emerging software engineering paradigms in which AI is not treated as an auxiliary feature or a narrow coding aid, but as a first-class participant in software conception, construction, execution, and evolution. Across recent work, the term denotes a shift from deterministic, code-centric, and human-interface-centric development toward intent-first, orchestration-centric, and agent-mediated development, where humans increasingly specify goals, constraints, and verification criteria while AI systems generate, compose, test, and sometimes operate software artifacts (Wang et al., 19 Mar 2026). Closely related formulations describe AI-native applications as systems built around AI as the system’s intelligence paradigm and around inherently probabilistic, non-deterministic behavior, so that software value depends not only on code, but also on model quality, orchestration, data, memory, and feedback loops (Cao et al., 16 Sep 2025).

1. Historical trajectory and definitional scope

Several papers describe AI-native software engineering as a historical transition rather than a single tool innovation. One line of argument distinguishes a Human Interface Era, an API-Centric Transition, and an Agent Interface Era. In the first, software is optimized for pages, forms, and workflows navigated manually by humans; in the second, software is optimized for endpoints and interoperability; in the third, software is optimized for AI agents that autonomously invoke and compose capabilities at runtime, with reliability rather than usability as the primary optimization target (Wang et al., 19 Mar 2026). A related literature uses the label SE 3.0 to describe a move from classical hand-coded engineering and AI-assisted coding toward intent-driven, conversation-oriented development with AI teammates (Hassan et al., 2024).

Within this literature, “AI-native” is used in at least three closely connected senses. First, it names systems whose essential function collapses if the AI component is removed, distinguishing them from conventional applications with AI added on top (Cao et al., 16 Sep 2025). Second, it names development workflows in which software is “not primarily written by humans at the code level,” but is instead produced through prompts, structured artifacts, and AI agents that generate requirements, designs, tests, and code (Stirbu et al., 29 Sep 2025). Third, it names a reuse regime in which developers increasingly rely on AI to synthesize software artifacts from learned patterns, rather than manually assembling libraries and frameworks from repositories (Mikkonen et al., 22 Jun 2025).

The field is not conceptually uniform. Some papers emphasize AI-native applications, meaning model-centered products; others emphasize AI-native software development, meaning a reorganization of the software lifecycle; still others emphasize agentic software engineering, meaning the rise of autonomous coding or planning agents as collaborators or teammates (Li et al., 20 Jul 2025). Despite this variation, a common denominator recurs: software engineering is no longer defined only by human authorship of deterministic code, but by the design and governance of systems in which natural-language intent, tool-using agents, retrieval and memory, and probabilistic outputs are central (Alenezi, 27 Jun 2026).

A recurrent corrective theme is that AI-native software engineering is not synonymous with “prompting a model for code.” Community-oriented work explicitly contrasts prompt-based code generation with an AI software engineer that participates in code-level tasks such as code generation, testing, and program repair, and in design-level tasks such as architecture exploration, requirements understanding, and requirements enforcement at the code level (Roychoudhury, 24 Aug 2025). This suggests that the topic is broader than code synthesis: it concerns the redistribution of engineering work across humans, agents, artifacts, and runtime infrastructures.

2. Core abstractions: intent, interfaces, capabilities, and orchestration

One of the most explicit conceptual contributions is the distinction between human interfaces and agent interfaces. An agent interface is defined as “a software interaction layer designed for machine invocation, characterized by structured inputs, explicit semantics, and deterministic execution,” while an invocable capability is defined as “a minimal, self-contained unit of functionality that exposes a structured interface and can be reliably executed by an AI agent without human intervention” (Wang et al., 19 Mar 2026). This reframes software functionality away from pages and features and toward capabilities and contracts.

In this framing, the practical formalism of AI-native software is not heavy mathematics but interface discipline: explicit operation names, typed parameters, semantic descriptions, input schemas, output schemas, constraints, validation rules, side effects, failure modes, and clear state transitions. These requirements are stricter than ordinary UI documentation because an autonomous agent cannot infer hidden context as a human user often can (Wang et al., 19 Mar 2026). The resulting design pressure is toward machine interpretability, reliable invocation, composability, and safe retries.

A parallel line of work describes AI-native engineering as intent-first. Here the primary input is not code but human intent expressed through natural language, examples, sketches, constraints, or structured prompts, and the primary engineering task becomes transforming that intent into runnable systems (Hassan et al., 2024). In the most developed compiler-oriented formulation, the compilation target is not merely source code but an FMware stack composed of prompts, foundation models, retrieval components, agentic workflows, guardrails, memory, evaluation infrastructure, and system parameters; compilation therefore becomes a search problem over heterogeneous probabilistic components rather than a deterministic translation problem (Cogo et al., 27 Oct 2025).

This broadens the unit of software composition. Prompt Sapper, an early infrastructure proposal for AI-native services, defines an AI chain as a modular workflow that assembles prompt calls to foundation models, calls to traditional AI models, and calls to external data or APIs, with workers as the functional units of the chain (Xing et al., 2023). Other papers use different vocabularies—agent workflows, cognitive architectures, semantic layers, or orchestrated workforces—but they converge on the same architectural point: the software artifact is increasingly a managed composition of model calls, tools, memory, retrieval, validation, and deterministic services, rather than a monolithic codebase alone.

A typical stack has begun to recur in the literature: foundational AI models and frameworks; LLM orchestration and integration platforms; vector databases and data engineering; observability, monitoring, and automation; model optimization and deployment; frontend and UI tooling; and local or on-device infrastructure (Cao et al., 16 Sep 2025). The insistence that “a model alone is not an application” reflects a core AI-native claim: system behavior arises from orchestration and surrounding engineering layers as much as from model weights.

3. Lifecycle reconfiguration and emerging methodologies

AI-native software engineering reconfigures the software lifecycle by moving human effort upward toward requirements, architecture, acceptance criteria, and oversight, while delegating more implementation detail to AI systems. The shift-up literature makes this explicit: humans work at a higher abstraction level than the AI system, concentrating on requirements definition, architecture, quality control, and operational oversight, while GenAI takes on design generation, code generation, and substantial portions of test generation and consistency checking (Stirbu et al., 29 Sep 2025). A closely related argument states that software engineering value is migrating from authoring deterministic code toward governing probabilistic, autonomous behavior (Alenezi, 27 Jun 2026).

Several methodological proposals instantiate this shift in different ways. The V-Bounce model adapts the traditional V-model into an AI-native SDLC in which AI is integrated throughout planning, design, implementation, testing, deployment, and maintenance, with a compressed implementation phase and greater emphasis on requirements, architecture, and continuous validation (Hymel, 2024). Each V-Bounce phase is described as a recurring cycle of Input, AI Generation, Human Review, Refinement, Approval, and Knowledge Capture, making validation rather than manual implementation the dominant human activity (Hymel, 2024).

The Shift-Up framework offers a more artifact-centered formulation. It reinterprets executable requirements, C4 architectural models, and ADRs as machine-readable guardrails for GenAI-native development. In its reported web-application evaluation, the process included stakeholder interview, SRS generation and three refinement iterations, user story mapping, transformation of user stories into Robot Framework acceptance tests in Given-When-Then style, generation of C4 and ADR artifacts, an implementation roadmap, and GitHub issues tied to acceptance tests; this produced 68 user stories, 175 Robot Framework acceptance test cases, and 10 implementation phases (Lipsanen et al., 22 Apr 2026). The claim is not that prompting disappears, but that prompting becomes subordinate to explicit requirements and architecture.

At larger organizational scale, the AI-Native Large-Scale Agile Software Development Manifesto proposes six principles: parallel processes, intent-driven teams, living knowledge, verification-first assurance, orchestrated agent workforces, and reusable blueprints (Britto et al., 8 May 2026). In this view, coordination should move away from meetings and static documents and toward shared context, machine-readable specifications, semantic layers, and specialized agent teams. The resulting organization is described as “Human intent, machine velocity, where human experts direct and AI agents deliver” (Britto et al., 8 May 2026).

Requirements engineering is correspondingly reinterpreted. AI-native RE literature argues that AI can extract requirements from unstructured sources, detect ambiguity and inconsistency, support evaluation and prioritization, and help maintain traceability, while humans remain responsible for domain interpretation, stakeholder negotiation, ethics, and final validation (Abbasi et al., 5 Oct 2025). A related guardrail-oriented perspective holds that RE becomes more rather than less important in AI-native workflows because early misunderstandings can propagate through generated architecture, tests, and code (Lipsanen et al., 22 Apr 2026).

4. Quality, verification, and trustworthy execution

A central tension in AI-native software engineering is that the dominant artifacts are increasingly probabilistic, but the surrounding engineering obligations remain exacting. Quality discourse therefore shifts from mere functional correctness to reliability, robustness, observability, maintainability, security, and verification. Grey-literature synthesis identifies seven prominent quality attributes for AI-native applications—Performance and Efficiency, Reliability and Robustness, Usability and User Experience, Security and Privacy, Scalability and Flexibility, Observability and Maintainability, and Data and Functionality Management—with particular emphasis on reliability and robustness, usability and UX, and scalability and flexibility (Cao et al., 16 Sep 2025).

Several papers argue that traditional code LLM evaluation is too narrow because it centers on pass/fail behavior or textual similarity while ignoring software engineering structure. The seNAI vision paper states that current pipelines “start with pre-training and end with evaluation using benchmarks,” but overlook modularity, single responsibility, cohesion, coupling, and abstraction; it therefore proposes SE-guided training and SE-grounded evaluation, including tasks such as refactoring low-quality code while preserving behavior and assessing $\mathrm{LCOM}$ and $\mathrm{CBO}$ (Saad et al., 19 Mar 2025). Its use of Bloom’s Taxonomy is meant to evaluate whether models can not only recall SE concepts but apply, analyze, evaluate, and synthesize with them.

In agentic systems, verification also becomes trajectory-level. One formalization models the agent loop as

$$a_t \sim \pi\!\left(a \mid s_t\right), \qquad s_{t+1} = f\!\left(s_t, a_t, o_{t+1}\right),$$

where behavior depends on policy, state, tool-mediated action, new observations, and memory updates (Alenezi, 27 Jun 2026). In such systems, long-horizon reliability is constrained by multiplicative error accumulation:

$P_{\text{success}}(n) = p^{\,n},$

so high local accuracy can still yield poor end-to-end performance as the number of dependent steps grows (Alenezi, 27 Jun 2026). This is one reason AI-native engineering emphasizes trajectory evaluation, recovery mechanisms, retries, and human checkpoints.

Trust is therefore repeatedly treated as a first-order engineering problem. Community-oriented work speaks of a trust deficit in AI-generated code and argues that trustworthy workflows require specification inference, explainability, program analysis, and AI-based verification and validation of AI-generated code (Roychoudhury, 24 Aug 2025). The same logic appears in guardrail proposals: executable acceptance tests, explicit architecture, and issue-linked validation convert vague intent into machine-checkable constraints (Lipsanen et al., 22 Apr 2026).

Security and governance likewise move inward, from external review to architectural necessity. One synthesis maps governance requirements to ISO/IEC 42001, IEEE 7000, and the NIST AI RMF, and highlights risks including tool misuse, data exfiltration, behavioral drift, and indirect prompt injection (Alenezi, 27 Jun 2026). Because AI-native systems may expose direct machine invocation pathways, open concerns include misuse, policy enforcement, privacy, model drift, and the challenge of maintaining transparent errors and visible side effects in black-box components (Cao et al., 16 Sep 2025).

5. Human roles, organizational forms, and the changing professional profile

The AI-native literature consistently rejects the equation of autonomy with human disappearance. Instead, it describes a reallocation of work. The Agentic Engineer is defined as the professional who designs, supervises, and governs agentic systems, with three associated shifts: the unit of work moves from functions to supervised agent workflows, correctness moves from binary assertions to statistical evaluation under uncertainty, and accountability moves from code authorship to outcome ownership (Alenezi, 27 Jun 2026). This implies that humans remain responsible for quality, safety, acceptance criteria, and production readiness even when an agent writes or executes much of the code.

A broad review of practice, education, and workforce implications reframes the field around three organizing principles—intent, collaboration, and verification—and operationalizes them as a nine-dimension competency model spanning specification, critical evaluation of AI output, AI-assisted debugging and verification, metacognition, agent orchestration and tool use, foundational CS and systems thinking, security and responsible use, human–AI collaboration, and continuous learning (Alenezi, 11 Jun 2026). In this account, the scarce human capability is not code production alone, but judgment under stochastic and sociotechnical conditions.

Organizationally, AI-native development encourages new distributions of responsibility. The Agentsway methodology describes a human orchestrator supervising planning, prompting, coding, testing, and fine-tuning agents, with retrospective learning loops that fine-tune models from prompts, code diffs, test results, and human annotations (Bandara et al., 26 Oct 2025). The AI-native large-scale agile literature generalizes this into intent-driven teams and orchestrated AI workforces, while the semantic layer or knowledge-graph perspective treats architecture, code, security, and development intelligence as linked machine-readable knowledge supporting reasoning and automation (Britto et al., 8 May 2026).

This professional shift also changes educational assumptions. Some curriculum work argues that code output alone can no longer be treated as a valid proxy for competence, because AI can produce artifacts while obscuring whether the engineer can specify, critique, secure, and verify them (Alenezi, 11 Jun 2026). A plausible implication is that the canonical measure of engineering expertise is moving from direct implementation fluency toward the capacity to define problems precisely, supervise probabilistic collaborators, and detect plausible-but-wrong outputs before they enter production.

The literature also repeatedly states that classical software engineering does not become obsolete. Rather, AI-native engineering depends on deterministic interfaces, secure APIs, infrastructure reliability, testing environments, architecture, and durable CS foundations (Alenezi, 27 Jun 2026). In that sense, AI-native software engineering is presented less as a replacement for software engineering than as a higher-order reorganization of its abstractions, artifacts, and accountability structures.

6. Empirical evidence, controversies, and open research problems

Empirical work supports the claim that AI-native practices are no longer merely speculative, but it also shows that the transition is uneven. The AIDev dataset, presented as the first large-scale dataset of autonomous coding agents in the wild, contains 456,535 pull requests by five autonomous agents—OpenAI Codex, Devin, GitHub Copilot, Cursor, and Claude Code—across 61,453 repositories and 47,303 developers (Li et al., 20 Jul 2025). In popular repositories, accepted PR rates are reported as 76.8% for humans, 65.3% for OpenAI Codex, 48.9% for Devin, 38.2% for GitHub Copilot, 51.4% for Cursor, and 52.5% for Claude Code, while documentation is a relative strength for some agents, with 88.6% acceptance for OpenAI Codex and 85.7% for Claude Code against a 76.5% human baseline (Li et al., 20 Jul 2025). The same work reports much faster closure times for some agent-authored PRs, but interprets this cautiously because faster closure may reflect efficiency, shallow review, or trust dynamics rather than unequivocal quality.

Productivity evidence is similarly mixed. One synthesis reports studies in which developers completed a bounded JavaScript task 55.8% faster with an AI assistant and field experiments across 4,867 developers showing a 26.08% increase in completed tasks, but it also cites a randomized controlled trial of 16 experienced open-source developers in which early-2025 AI tools increased completion time by 19%, despite developers expecting a 20–24% speedup (Alenezi, 27 Jun 2026). Another review therefore argues that benefits are strongly context-dependent and that AI often reallocates effort from first-draft coding to prompt refinement, verification, debugging, and security review (Alenezi, 11 Jun 2026).

This empirical ambiguity underlies several controversies. One line of critique compares current generative reuse to cargo cult development, warning that developers may trust generated artifacts without understanding provenance, semantics, or architectural fit (Taivalsaari et al., 27 Aug 2025). Related concerns include hallucination, repeatability, privacy and licensing exposure, slopsquatting, maintainability of flat or monolithic generated code, skill erosion among junior developers, and the risk that prompt engineering is mistaken for a complete engineering method (Mikkonen et al., 22 Jun 2025). These criticisms do not deny the productivity or accessibility benefits of AI-native workflows; rather, they question whether present practices are systematic, auditable, and maintainable enough for production use.

Open research problems are correspondingly broad. Recurrent themes include capability granularity, standardization of agent interfaces, dual-audience design for humans and agents, evaluation beyond pass rates, trustworthy requirements engineering, provenance tracing, reproducible compilation of FMware, and secure-by-default orchestration (Wang et al., 19 Mar 2026). At ecosystem scale, one theoretical proposal argues that multi-agent AI software environments should be studied as complex adaptive systems, with emergent properties such as architectural entropy, cascade failures, and comprehension debt; it formalizes micro-level and macro-level state variables and proposes causal emergence when $EI_{\text{macro}} > EI_{\text{micro}}$ (Russo, 20 Apr 2026). This suggests that future AI-native governance may need to shift from artifact-level monitoring to ecosystem-level observability.

A persistent misconception is that AI-native software engineering simply means “more code generation.” The literature is more demanding. It points instead to a redefinition of software engineering around machine-invocable capabilities, structured intent, orchestrated agents, living knowledge, verification-first assurance, and outcome ownership. Whether these elements stabilize into a mature discipline remains an open question, but the field’s own self-description is already clear: humans navigate goals, constraints, and accountability, while AI increasingly invokes, composes, and implements the software system that realizes them (Wang et al., 19 Mar 2026).