Submitted:
07 November 2026
Posted:
09 November 2026
You are already at the latest version
Abstract
Large language models and coding agents are changing how digital solutions are specified, built and maintained. Conventional software lifecycles, however, assume extended manual effort, relatively stable requirements and sequential progression, and they offer little protection against non-deterministic generation, self-confirming validation and nominal human review. Following Design Science Research, this study designed IntDEx (Intelligence-native Delivery Experience), an engineering framework for delivering digital solutions with AI as the primary enabling layer, and evaluated it in a single real case: the construction of a sovereign data-science platform for public-health experimentation. IntDEx combines a seven-phase non-linear delivery flow, an accountability-based role model and graded conformance profiles with two assurance constructs, enforceable human oversight and evidential independence. A solution of 52,598 lines of code was rebuilt by a model from a different provider using IntDEx artefacts alone, reproducing approximately 95% of the tested routes and user journeys, whereas an intent-only baseline produced a non-working system. Security controls that were implicit in the original implementation were weakened in the rebuild. Enforced checkpoints changed the outcome in 7 of 17 major decisions, and cross-provider review led to 4 human-confirmed corrections that self-assessment would not have produced. These results indicate feasibility rather than general effectiveness, and multi-case replication is required.
Keywords:
AI-native engineering
; evidential independence
; human oversight
; software process models
; LLM-based software engineering
; AI governance
; digital sovereignty
; IntDEx
; AI SDLC
1. Introduction
Large language models (LLMs) and agentic coding tools are changing how software is conceived, built and maintained [1,2,3]. Conventional software development lifecycles (SDLCs), including most agile variants, assume that implementation consumes substantial human effort and time, that requirements are relatively stable within a planning horizon, and that work progresses from analysis to implementation and testing. AI-native delivery challenges each assumption. Generation is fast and non-deterministic [4], requirements evolve as teams observe generated results, and time-boxed stages calibrated to human throughput lose much of their purpose. New bottlenecks move to specification, review and verification [5], and simply instructing an agent to produce code ("vibe coding") is not a safe basis for production systems, in which even the question of why a behaviour exists may become unanswerable [6].
The risks are documented in the peer-reviewed literature. AI-generated code frequently contains security weaknesses [7], developers assisted by AI can produce less secure code while feeling more confident about it [8], and code-generating models hallucinate software packages that attackers can register [9]. Agents that read repositories and retrieved documents are exposed to indirect prompt injection [10,11]. LLMs struggle to correct their own reasoning without external feedback [12] and tend to favour their own outputs when used as evaluators [13,14]. On the human side, decades of research on automation show that reviewers over-trust automated recommendations [15,16]. Together, these findings indicate that an AI-native process can appear complete and well-validated while resting on self-referential evidence and limited review.
Responses so far fall into three groups. Standards and methods for managing AI projects, such as the PMI AI standard [17] and CPMAI [18], focus on the management of AI initiatives rather than on AI as the delivery engine. Practitioner playbooks and patterns for AI-native engineering [19,20,21,22] and spec-driven development [23] provide workflow guidance, but they do not specify enforceable controls or evaluation evidence. The closest academic proposal, the V-Bounce model [24], places AI as the implementation engine with human review at each phase. It has not been applied in practice, however, and it does not address role accountability, regulation or sovereignty, nor does it require evidence to originate independently of the authoring model. To our knowledge, no published framework combines an end-to-end AI-native delivery model with auditable human decision rights and a rule on the provenance of correctness evidence, and none has been evaluated empirically.
This paper addresses that gap. Its contributions are:
- C1. IntDEx, a technology-agnostic engineering framework for AI-native delivery comprising seven defining characteristics, a seven-phase non-linear delivery flow, an accountability-based role model, graded conformance profiles and proposed practices;
- C2. two assurance constructs: enforceable human oversight, which makes human review a recorded, attributable and blocking control, and evidential independence, which admits a correctness claim only if its evidence originates from a source other than the authoring model;
- C3. a preliminary single-case evaluation, conducted under Design Science Research, comprising a reconstruction-from-artefacts experiment with an intent-only baseline and an analysis of checkpoint and cross-model review records;
- C4. an explicit analysis of threats to validity and a measurement agenda for multi-case replication.
Following IntDEx does not by itself make an implementation production-ready. Readiness depends on the selected conformance profile, the controls actually enforced, the evidence produced and the operational setting. Section 2 reviews related work. Section 3 describes the research method and the case. Section 4 presents the framework, Section 5 the evaluation results and Section 6 their discussion, including threats to validity. Section 7 concludes. Detailed phase specifications, role descriptions, operational practices and the full adoption checklist are provided in the Supplementary Materials (Sections S1–S7).
2. Background and Related Work
2.1. Software Development Projects and Hybrid Delivery
Empirical studies show that most organisations combine plan-driven and agile practices rather than using either in pure form [25], and that hybrid approaches are delivering more in terms of project success [26]. Methods such as SAFe [27], and PM² Agile [28] integrate iterative delivery into plan-driven governance, PRINCE2 can also accept agile in its stages, while Kanban emphasises continuous flow, work-in-progress limits and readiness-based replenishment [29]. Research on flow in software project management identifies continuous flow as an alternative to time-boxed iterations in complex environments [30]. Behaviour-driven development (BDD) established the idea that executable, behaviour-oriented specifications rather than code can be the durable engineering asset [31]. All of these methods assume that humans produce the artefacts and that cadences are calibrated to human throughput. IntDEx is designed to operate inside such hybrid contexts, but it suggests replacing time-boxed iterations with flow-based, readiness-triggered delivery, non-linear phase execution and a managed AI delivery engine.
2.2. LLM-Based Software Engineering and AI-Native Lifecycles
Surveys document the rapid uptake of LLMs across requirements, design, coding, testing and maintenance tasks, and they identify hallucination, non-determinism and weak evaluation as open problems [1,2,3]. Studies of AI pair programmers report useful but uneven output quality [32], and re-testing shows that the correctness of generated code is substantially overestimated by weak test suites [33]. Practitioner sources describe the shift of the engineer from implementer to orchestrator of agents, recommend shared context files, small human-in-the-loop rounds and evaluation sets [5,21], propose an AI-native SDLC playbook [19,20] and identify patterns such as the move from implementation/coding to describing the intent [22]. Spec-driven development makes a structured specification, rather than prompts, the artefact against which the AI executes [23]. The V-Bounce model is the most explicit academic lifecycle proposal [24]. Its validation, however, relies on human review and on AI quality agents checking generator agents, without requiring independence of evidence. Software engineering for machine learning and MLOps address the lifecycle of models inside products [34,35,36,37], not the use of AI as the engine that delivers software. The term "developer experience" is established in industry [38], but it had not been defined for settings in which AI is the primary interface for delivery.
2.3. Generative AI Risk, Safety and Governance
Governance frameworks such as the NIST AI Risk Management Framework [39], the ISO/IEC 22989 terminology [40], the OECD AI Principles [41] and the EU Ethics Guidelines for Trustworthy AI [42] stress transparency, accountability and human agency. The EU AI Act [43] makes human oversight and traceability legal obligations for high-risk systems. Pattern catalogues (a Collection of Best Practices for AI Governance and Engineering) translate such principles into governance and engineering practices [44], and internal algorithmic auditing frameworks show how accountability can be built into development stages [45]. On the technical side, hallucination is a pervasive property of generative models [46], and generated code and dependencies form a new attack surface [7,9,47]. Prompt injection in particular cannot be solved reliably by instructions placed in the prompt, because injected text and instructions reach the model through the same channel [10,11]. Evidence that LLMs cannot reliably self-correct without external feedback [12] and that they prefer their own generations when acting as judges [13,14] directly motivates the evidential-independence rule of IntDEx.
2.4. Human-in-the-Loop Oversight and Automation Bias
Machine learning research shows that human contributions improve model behaviour when interaction points are designed deliberately [48]. Human-centred AI argues that high automation and high human control can coexist if control points are explicit [49], and studies on levels of automation separate information acquisition, analysis, decision and action [50]. Automation bias is, however, a clear phenomenon. Reviewers accept automated recommendations without independent verification, especially under time pressure and when output appears confident [15,16]. For AI-native delivery, this means that human oversight cannot be assumed to work simply because a review step exists. Oversight has to be designed, recorded and periodically tested as a control, which is the position IntDEx adopts.
2.5. Positioning of IntDEx
IntDEx is positioned as an assurance-oriented, end-to-end AI-native delivery framework rather than as a replacement for adjacent methods (Table 1). It reuses established tooling and practices and contributes the governed/managed delivery engine that connects intent, generative execution, independent evidence, human decision rights, release traceability, monitoring, cost, compliance and sovereignty.
3. Material and Methods
3.1. Research Design
The study follows Design Science Research (DSR), in which an artefact is designed and evaluated to address a class of practical problems [51,52]. Here the artefact is a method, the IntDEx framework. The work followed the six activities of the DSR process model of Peffers et al. [53] (Table 2). Framework development, literature review and practical implementation evolved concurrently. In DSR terms this is a sequence of build–evaluate iterations within the design cycle [51], in which problems observed during platform delivery triggered framework revisions and each revision was checked against the literature. Reporting follows the alignment between design science and software engineering research proposed by Engström et al. [54]. The evaluation is ex post and naturalistic in the sense of the FEDS framework [55]. The framework was applied to a real delivery and assessed after use, and the empirical component is reported as an exploratory single case following Runeson and Höst [56].
3.2. Research Questions
The primary research question is RQ1: How can an engineering framework be structured to support the AI-native delivery of digital solutions while maintaining governance, human oversight, reproducibility, regulatory and sovereignty awareness? Three supporting questions refine it. RQ2: How does AI-native delivery differ from traditional software development lifecycles in its phases, artefacts, roles, responsibilities and working practices? RQ3: How can human oversight and evidential independence be made enforceable and auditable rather than remaining an informal recommendation? RQ4: Can a digital solution be reconstructed from AI-native delivery artefacts without access to its original source code, and with what level of behavioural consistency? RQ1 and RQ2 are addressed mainly by the design (Section 4), and RQ3 and RQ4 by the evaluation (Section 5).
3.3. Case Context
IntDEx emerged from the research project "Interoperability and utilisation of epidemiological surveillance data with artificial intelligence". The project required the rapid development of a data-science platform and supporting tools that would provide a standalone, sovereign environment for public-health data experimentation. Conventional methods were considered insufficient because of the time needed to implement them and knowledge gaps in the research team, and the project therefore adopted AI-native practices. The original solution was built with GPT-5.3-Codex as the primary model in Visual Studio Code, with auxiliary AI services such as Microsoft Copilot. The resulting custom codebase, produced with AI assistance, comprised 52,598 lines of python code (LOC). The unit of analysis is the delivery of this platform. The data analysed are the IntDEx delivery artefacts, the checkpoint decision records and the logs of prompt executions and cross-model reviews.
3.4. Evaluation Procedures
E1 – Reconstruction from artefacts (RQ4). The solution was rebuilt by Claude Opus 5 in the same IDE, using only the artefacts produced under IntDEx (intents, prompts, constraints, contexts, test prompts and test results, and the delivery-engine configuration) and without access to the original source code. As a baseline (B0), the same reconstruction was attempted from the major initial intent alone, without IntDEx artefacts. Behavioural consistency was measured as route-surface similarity: the share of tested URL patterns and screen-to-screen user journeys that produced the same observable behaviour in the original and the rebuilt solution. It was also assessed by combining code analysis, human interface testing and review by models from a different provider family. Deviations were then classified across six reproducibility dimensions: behaviour, security, data structures, architecture and configuration, operational capabilities and delivery-engine configuration. Any reproducibility claim therefore states what was tested, the expected level of similarity and the evidence used.
E2 – Enforced human oversight (RQ3). The decision records of the 17 major checkpoints raised during delivery were analysed. A checkpoint was counted as outcome-changing if the human decision differed from the engine's proposal, either by halting progress because the engine's evidence was insufficient or by correcting the engine's severity classification.
E3 – Cross-model evidence (RQ3). In more than 70 prompt executions, the output of the authoring model was reviewed by a model from a different provider family (cross-model review, XMOD). Deviations between the two were counted, and a deviation was counted as valid if it led to a human-confirmed change that self-assessment by the authoring model alone would not have produced.
All analyses are descriptive. Given one project and one reconstruction run, no multi-experiment statistics are reported.
3.5. Use of Generative AI
Generative AI is both the object and an instrument of this study. GPT-5.3-Codex built the original solution, Claude Opus 5 performed the reconstruction, and models from different provider families performed cross-model review. Their roles are described in Section 3.3 and Section 3.4. The use of AI tools in preparing the manuscript is declared in the Acknowledgments.
4. The IntDEx Framework
4.1. Core Concepts
AI-native delivery includes the complete project or product delivery flow, from inception to retirement, in which AI is the foundational operating and tooling layer. If AI were removed, the flow would break rather than slow down. The AI delivery engine comprises the tools, agents, models, pipelines, IDE, endpoints, governance, control and orchestration used by the team to describe, design, build, validate, deliver and maintain a digital solution. IntDEx treats the engine and the delivered digital solution as distinct objects, each governed and versioned independently. Generative creation is the AI-native build phase, in which prompts, models, constraints and context produce behavioural artefacts. Regulatory role-drift is a change in the organisation's role under applicable regulation, for example from deployer to provider under the EU AI Act [43]. IntDEx is a delivery framework, not a technology stack, product or reference architecture, and it is deliberately technology-agnostic. Extended definitions and the list of delivery problems the framework targets are given in Supplementary Material, Section S1.
4.2. Defining Characteristics
Seven characteristics define the framework (Table 3). Several are not new observations in themselves. Emergence, for instance, is described by complex adaptive systems theory and by emergent design in agile practice. What differs in AI-native delivery is where these properties occur and at what speed. In traditional development the work itself is deterministic, and emergence appears at the level of the system, organisation or requirement set. In AI-native delivery, emergence appears in every step that relies on non-deterministic generation. Behaviour is the primary acceptance reference, but source code, infrastructure definitions, dependencies, data schemas and binaries remain security, operational, forensic and supply-chain artefacts that are subject to deterministic inspection. More detail’s are given in Supplementary Material Section S2.
4.3. Generative Capability, Control Capability and Enforcement Classes
IntDEx separates the generative capability (models and agents that interpret intent, create artefacts and propose changes) from the control capability, which determines what the generative capability may read, change, execute, export and release. A model instruction is considered guidance unless an independent mechanism validates or enforces it. High-impact controls should move progressively out of the authoring model into deterministic or independently governed mechanisms such as repository protection, policy evaluation, model-gateway policy, sandbox permissions, identity and secrets infrastructure, and CI/CD admission. The engine may explain a failure and propose a remedy, but it must not be able to redefine a policy, approve the exception and execute a protected action in the same transaction.
Each important control declares its enforcement class. A control is GUIDANCE when compliance depends on model or human interpretation. It is DETECTIVE when an independent mechanism identifies but does not block a violation, and WORK-BLOCKING when a deterministic mechanism prevents the change or repository build, merge or workflow transition. A DEPLOYMENT-BLOCKING control is enforced by the release pipeline. A RUNTIME-ENFORCED control is applied by execution-time infrastructure, and a HUMAN-DECISION control requires an authenticated human decision. Compliance reports must state the class actually implemented, must not report a GUIDANCE control as technically enforced, and periodically retest a sample of controls.
4.4. Enforceable Human Oversight
In IntDEx, human oversight counts as implemented only when it is expressed as a checkpoint, recorded in a machine- and human-readable log, and verifiable. It consists of four elements.
Mandatory checkpoints. The engine must not proceed autonomously in the following situations: (1) major intent creation or change; (2) changes that significantly alter user-visible behaviour, business rules or data contracts; (3) changes affecting security, authentication, authorisation, privacy or personal data; (4) database schema changes; (5) major release approval; (6) breaches of cost or risk thresholds; (7) cases in which the engine reports that it cannot validate its own output; (8) enabling telemetry that can be traced to named individuals; (9) changes that could alter the organization’s regulatory role; and (10) confirming and implementing AI-use disclosure for people affected by the delivered solution.
Accountability. Each checkpoint is owned by a named role (Section 4.7). The engine holds no approval authority for major checkpoints.
Decision record. Every checkpoint produces an entry with the reviewer identity, role, decision, rationale, artefacts inspected, linked evidence, change severity and timestamp. The engine may create the entry but must not populate the human-validation field. The reviewer must inspect the underlying artefacts and evidence, not a summary written by the engine that did the work.
Blocking rule. Unresolved checkpoints accumulate as debt. When the number of unvalidated high-severity checkpoints exceeds the threshold in the engine manifest, the engine must stop and report the blocking condition.
To avoid treating every checkpoint as equally heavy, the tier is assigned per change. Tier 1 (standard) changes may use asynchronous, time-limited review. Tier 2 (elevated) changes affecting personal data, authentication, schemas, public API contracts or cost and risk thresholds require synchronous, blocking review. Tier 3 (critical) changes affecting regulatory classification, sovereignty or safety additionally require an escalated reviewer. Where the delivered solution itself makes AI-supported decisions at runtime, build-time checkpoints are not sufficient. The solution must also keep its own operational oversight records.
IntDEx also treats the reviewer as a failure mode. Automation bias [15,16], anchoring on the engine's conclusion and the erosion of skills in teams that no longer produce artefacts themselves [5] grow as the engine improves, because confident, well-formatted output is harder to challenge. Acceptance criteria are therefore confirmed before implementation exists. A separately owned re-sampling control periodically re-examines a risk-based sample of approved checkpoints, and a rejection rate of zero is treated as a finding to investigate. IntDEx does not claim that checkpoints reliably catch machine errors. It claims that a checkpoint that is recorded, attributed and inspectable can be audited, whereas informal review cannot. The full checkpoint specification, tier criteria and re-sampling procedure are given in Supplementary Material Section S2.
4.5. Evidential Independence
When one model authors the intent, prompt, implementation, test and test result, a single misunderstanding can propagate consistently through all of them. Traceability then appears complete and validation green while the whole chain is wrong, because traceability among artefacts written by one author shows internal consistency, not correctness. This risk grows as adoption succeeds, since fewer independent references remain against which the engine's output can be checked. It is consistent with evidence that LLMs do not reliably self-correct [12] and favour their own outputs [13].
IntDEx therefore admits a claim of correctness only if its evidence originates from a source other than the model that produced the work. Four admissible sources are ranked by strength: (1) executed evidence, such as exit codes, test results, build logs, HTTP responses or database-state checks; (2) human evidence, such as acceptance criteria validated before implementation or documented checkpoint decisions; (3) cross-model evidence from a model of a different provider family, which is advisory and reduces but does not eliminate risk; and (4) prior-artefact evidence, such as comparison with a baseline that predates the change. A statement by the authoring model that a check passed is recorded as UNVERIFIED, not as a pass. The same rule applies to cost, so model-reported consumption remains an unverified self-report until it is checked against provider telemetry. Figure 1 illustrates the admissibility rule, under which evidence is admissible for a change only if its strength is commensurate with the change's severity. Teams may allow a same-model feedback loop for low-criticality work, but this is a recorded decision, not a default.
IntDEx formalises evidential independence and enforceable human oversight through a formal model and seven decidable conformance rules (Supplementary Material Section S5.10).
4.6. Delivery Flow
The IntDEx delivery flow has seven phases (Table 4). Phases are revisited in any order as needed, reflecting the non-linear and emergent character of AI-native work. Phase 2 places enforcement at boundaries that the authoring model cannot rewrite, and it records the processing location, data-transfer basis and provider dependency of every model used. In Phase 3, pair interaction (e.g., Developer with Analyst or Tester) is the default working mode [60]. A prompt that serves a new intent becomes a new prompt file, whereas a better execution of the same intent becomes a new version. After implementation, the engine records the decisions it made that the prompt did not state, such as file names, tables and libraries (Deterministic Data), to support later rebuilds. Phase 5 Release bundles contain everything needed to reproduce behaviour, including prompt bundles, model, constraint and context versions and validation metadata. Rollback returns to a prior behavioural bundle and must have been exercised at least once. In Phase 6, monitoring signals are inputs to delivery rather than post-release concerns, and delivery-engine telemetry is kept separate from solution telemetry. The phase-level comparison with the closest existing practice and the division of work between humans and the engine are specified in Supplementary Material Section S3 (Table S1–S15).
4.7. Roles and Accountability
IntDEx does not invent new job titles. It assigns AI-native responsibilities to seven roles. The Business Owner owns intent, success criteria and the business go/no-go. The Delivery Manager owns scope, cost and risk escalation and records release events, reflecting PMI's emphasis on governance and value [17]. The Architect owns the engine's design, model management, sovereignty, security, privacy and compatibility decisions, and the engine's capability boundary. The Analyst owns intent creation and change. The Developer generates and refines behaviour with the engine but does not approve their own changes. The Tester owns the classification of every recorded result by evidence source. The Risk Manager owns ethical constraints, sovereignty monitoring and regulatory role-drift, and this role may be combined with the Delivery Manager. One person may hold several roles, but the person who prepares a change must not approve it at a mandatory checkpoint or accept its validation evidence. Specialist functions such as security, platform or database engineering remain relevant and may fill these roles In a team depending on product delivery needs. Teams are aligned to business domains, are sized by business and regulatory complexity rather than technical complexity, and typically have three to five members. Full role descriptions and the RACI matrix are given in Supplementary Material Section S4 (Table S16).
4.8. Adoption and Conformance
IntDEx can be adopted incrementally. Minimum adoption requires the following elements: (1) AI prompting as the primary interface for work; (2) versioned engine manifest, governance, intent, prompt, constraint, context, test-prompt and test-result artefacts from which the solution can be rebuilt; (3) at least one blocking human checkpoint; (4) at least one item of admissible evidence before production; (5) a deterministic security check combined with cross-model or human review; (6) a written capability boundary for the engine; (7) a blocking ethical constraint with a named owner; and (8) a tested rollback. Five combinable conformance profiles extend this baseline. CORE covers governed intent, independent evidence, security checks, rollback and accountability. GOVERNED adds machine-readable controls, decision and evidence records, role separation and automated conformance checks. REGULATED adds regulatory classification, privacy controls, retention and formal exceptions. SOVEREIGN adds provider and jurisdiction records and a tested, not merely declared, capability to route work to another model or provider, or to a self-hosted model where policy allows [61]. HIGH-AUTONOMY adds sandboxing, least-privilege identity, outbound restrictions and negative testing of stopping controls. A conformance claim states the profile, framework version, implementation version, unresolved exceptions and assessment date. Conformance requires evidence that controls work, so a control that exists but has not been shown to work is a gap, not a pass. IntDEx does not guarantee legal or regulatory compliance, and that responsibility remains with the adopting organisation. The full checklist, profile criteria and operational practices (risk controls, autonomy limits, cost control, sovereignty, governance, ethics and continuous behaviour validation) are given in Supplementary Material Sections S5 and S7.
5. Results
5.1. Reconstruction from Artefacts (E1)
Table 5 compares the original solution, the IntDEx-based reconstruction and the intent-only baseline (B0). The baseline B0 produced a codebase of about 11,000 LOC that did not run, so route-surface analysis was not possible. The reconstruction from IntDEx artefacts produced a working solution in which approximately 95% of the tested URL patterns and screen-to-screen user journeys exhibited the same observable behaviour as the original. This figure describes route-surface similarity only. It does not imply equivalence of architecture, data design, security or other implementation properties.
5.2. Deviations Beyond Route Behaviour
Deviations were observed in three of the six reproducibility dimensions (Table 6). The security regression is the most consequential finding. Defensive controls such as input validation, sanitisation, rate limiting and human-verification mechanisms were implemented more weakly in the rebuild. These controls were implicit (read between the lines) in the original implementation rather than represented explicitly as governed intents or security artefacts. The result indicates that AI-native reconstruction depends strongly on artefact completeness, and that controls not expressed as artefacts are not reliably reproduced. The finding led to a design revision, namely recording Deterministic Data and completing prompts with implementation details after each implemented prompt (Section 4.6).
5.3. Enforced Human Oversight (E2)
Across the 17 major checkpoints, enforced human review changed the outcome in 7 cases (41%) (Table 7). In 3 cases, the reviewer halted progress because the evidence presented by the engine was judged insufficient. In 4 cases, the reviewer corrected a severity classification proposed by the engine. The remaining 10 checkpoints confirmed the engine's proposal.
5.4. Cross-Model Evidence (E3)
Across more than 70 prompt executions, the cross-provider reviewing model deviated from the authoring model 19 times. Four of these deviations (21%) led to a human-confirmed change that self-assessment by the authoring model alone would not have produced. The other 15 deviations were reviewed and did not lead to a change. In both E2 and E3, therefore, a non-self source changed outcomes in cases that the engine's own assessment would have passed.
6. Discussion
6.1. Answers to the Research Questions
RQ1. The answer is a framework that separates the AI delivery engine from the delivered solution, governs both through versioned artefacts, and connects them through a non-linear flow in which human decision rights, evidence provenance and enforcement classes are explicit (Section 4). Regulatory and sovereignty awareness is built-in are handled as constraint artefacts with named owners and tested, rather than declared, capabilities.
RQ2. AI-native delivery differs from conventional lifecycles less in its activities than in where effort, risk and evidence sit. Coding/building becomes easy and fast, while specification, verification and accountability become the bottlenecks [5]. Intent replaces user stories, behaviour replaces code as the acceptance reference, flow replaces time-boxes, maintenance becomes governed behaviour evolution, and roles shift from producing artefacts to directing, validating and approving them (Table 3 and Table 4).
RQ3. Oversight becomes enforceable when it is expressed as a checkpoint with a named owner, an engine-unsignable decision record and a blocking rule. The E2 and E3 records indicate that such controls are not ceremonial. Seven of 17 major decisions changed, and cross-provider review surfaced corrections that self-assessment would not have produced. This pattern is consistent with the literature on LLM self-evaluation [12,13]. The authors also observed that the existence of checkpoints and cross-model review appeared to improve the authoring model's own reliability, but this hypothesis was not tested.
RQ4. A working solution could be reconstructed without the original source code, with high route-surface similarity, whereas the intent-only baseline failed. Reconstruction was not equivalent in architecture, data design or security. Reproducibility from artefacts should therefore be claimed per dimension and remains bounded by artefact completeness. This makes quality as reproducibility from artefacts, rather than delivery speed, the primary evidential claim of IntDEx. The artefacts proved sufficient to describe, explain and rebuild the delivered behaviour, which also supports their use as compliance evidence.
6.2. Implications for Practice and Research
For practitioners, the results suggest three priorities. First, controls that are implicit in an implementation, security controls in particular, must be made explicit as governed artefacts if they are to survive regeneration. Second, an AI-native pipeline/mechanism should classify evidence by source and should never record a self-reported pass as verified. Third, human checkpoints should be risk-tiered and periodically re-sampled, since a register in which almost everything is approved is more likely to indicate rubber-stamping than quality. IntDEx is intended to complement project and product management methods [26,27,28], DevSecOps and MLOps [36] rather than to replace them, and teams can adopt individual practices without the whole framework.
For research, the framework offers testable constructs such as admissible evidence, enforcement classes, checkpoint debt reproducibility results. A similar delivery initiative ppshould apply IntDEx and a simpler AI-native or spec-driven approach to the same requirements, repeat each condition several times to account for non-determinism, and report effectiveness, efficiency and assurance separately. Table 8 lists the measures that the decision records and checkpoints already support.
6.3. Threats to Validity
Threats are discussed using the classification of Wohlin et al. [62] and the case-study guidance of Runeson and Höst [56].
Construct validity. Route-surface similarity is a narrow proxy for behavioural equivalence. It captures routes and screen-to-screen journeys but not response content, edge cases or non-functional properties, so the 95% figure should not be read as functional equivalence. Outcome-changing human checkpoints and XMOD deviations were defined by the author and classified by one human evaluator. A severity reclassification counts as a change of outcome, but not every reclassification may matter downstream. The admissibility rule in Figure 1 is a ranking guideline, not a precise measurement.
Internal validity. The framework was designed, applied and evaluated by its authors, and it co-evolved with the case, so improvements may reflect learning effects rather than the framework itself. The original and reconstructed solutions were produced by different models from different providers. This was intended to test artefact sufficiency independently of the authoring model, but model capability is confounded with artefact quality. The artefacts may also contain implementation detail that leaks the original design, which would inflate similarity. Conversely, missing security artefacts depressed it.
External validity. The evidence comes from one project, one domain (public-health research), one research team, a codebase of about 53,000 LOC and specific model versions. Results may not transfer to larger organisations, regulated production environments, other domains or later model generations. Several thresholds in the framework, including team size, event cadence and tier criteria, rest on practitioner experience rather than measurement.
Reliability and conclusion validity. Each condition was run once. Because generation is non-deterministic [4], repeated runs could produce different similarity values and deviation profiles. Provider-side model updates can also change behaviour without notice, which limits exact replication. Sample sizes (17 checkpoints, more than 70 executions) are small and support descriptive statements only.
Researcher bias. The reconstruction test and the classification of outcomes were performed by one author. Mitigations included combining code analysis with human interface testing and with review by models from a different provider family, and retaining decision records and engine configuration for audit. These mitigations do not replace independent evaluation. The planned multi-case replication therefore involves independent teams, at least one domain outside public health, repeated runs per condition and the reporting of all results regardless of outcome.
6.4. Limitations and Future Work
Beyond the validity threats above, IntDEx is a baseline version, and its components have been specified and tested to different depths because the work initially served one delivery project. Regulatory references reflect the EU framework at the time of writing, including the amendments to the AI Act introduced by Regulation (EU) 2026/1744, and may change. Future work will report repeated reconstruction runs with the retained engine configuration, comparative studies using the measures in Table 8, and further work on automated prompt evaluation, adaptive routing and drift detection. Proposed changes to the framework's prescriptive content will be recorded in a public issue log together with their supporting evidence.
7. Conclusions
This paper introduced IntDEx, an engineering framework for the AI-native delivery of digital solutions in which AI is the main instrument for specification, design, coding, documentation and maintenance. IntDEx distinguishes the AI delivery engine from the delivered solution and organises delivery as a non-linear, seven-phase flow with explicit human decision rights. It contributes two assurance constructs: enforceable human oversight, which turns review into a recorded, attributable and blocking control, and evidential independence, which refuses to treat an authoring model's self-assessment as evidence. A single-case DSR evaluation showed that a working solution could be rebuilt from IntDEx artefacts with high route-surface similarity where an intent-only baseline failed, that implicit security controls were not reliably reproduced, and that enforced checkpoints and cross-provider review changed outcomes that self-assessment would have passed. These results establish feasibility, not general effectiveness. Independent, repeated and comparative evaluation across organisations and domains is the necessary next step.
Supplementary Materials
The following supporting information is provided with this article: Section S1: Scope, definitions and problems addressed; Section S2: Extended description of the IntDEx characteristics, enforceable human oversight and evidential independence; Section S3: Phase-level specification of the delivery flow, Table S1–S15; Section S4: Roles, responsibilities and RACI matrix, Table S16; Section S5: Operational practices and controls, Table S17; Section S6: Background on the origins of IntDEx and hybrid delivery; Section S7: Adoption, tailoring and conformance checklist. Section S7: Available Data.
Author Contributions
Conceptualization, S.K.; methodology, S.K.; validation, S.K. and M.M.G.; investigation, S.K.; writing—original draft preparation, S.K.; writing—review and editing, M.M.G. and P.V.; supervision, P.V. All authors have read and agreed to the published version of the manuscript.
Funding
This research received no external funding.
Institutional Review Board Statement
Not applicable. The study did not involve human participants or animals; the evaluation analysed software artefacts, delivery records and model outputs produced by the authors.
Ethics Statement
The research was conducted in accordance with the research ethics standards of the Ionian University and with the principles of the EU Ethics Guidelines for Trustworthy AI. No personal data were processed for the evaluation reported in this article.
Informed Consent Statement
Not applicable.
Data Availability Statement
The IntDEx artefact templates, the delivery-engine configuration used for the reconstruction, the anonymised checkpoint decision records and cross-model review logs, and the evaluation scripts are available at Supplementary Material Section S8. The source code of the data-science platform is not publicly available as it is still under further development. It can be made available to reviewers on request.
Acknowledgments
During the preparation of this manuscript, the authors used Microsoft Copilot, ChatGPT and Gemini for grammar and style checking, for improving consistency and readability, and as search tools for relevant open resources. The authors have reviewed and edited the output and take full responsibility for the content of this publication.
Conflicts of Interest
The authors declare no conflicts of interest.
Abbreviations
The following abbreviations are used in this manuscript:
| ACBV | Automated Continuous Behaviour Validation |
| BDD | Behaviour-Driven Development |
| BO | Business Owner |
| DM | Delivery Manager |
| DSR | Design Science Research |
| HITL | Human-in-the-Loop |
| IntDEx | Intelligence-native Delivery Experience |
| LLM | Large Language Model |
| LOC | Lines of Code |
| RACI | Responsible, Accountable, Consulted, Informed |
| SBOM | Software Bill of Materials |
| SDLC | Software Development Lifecycle |
| XMOD | Cross-model (different provider family) review |
References
- Fan, A.; Gokkaya, B.; Harman, M.; Lyubarskiy, M.; Sengupta, S.; Yoo, S.; Zhang, J.M. Large Language Models for Software Engineering: Survey and Open Problems. In Proceedings of the 2023 IEEE/ACM International Conference on Software Engineering: Future of Software Engineering (ICSE-FoSE), Melbourne, Australia, 14–20 May 2023; pp. 31–53. [Google Scholar] [CrossRef]
- Hou, X.; Zhao, Y.; Liu, Y.; Yang, Z.; Wang, K.; Li, L.; Luo, X.; Lo, D.; Grundy, J.; Wang, H. Large Language Models for Software Engineering: A Systematic Literature Review. ACM Trans. Softw. Eng. Methodol. 2024, 33, 220. [Google Scholar] [CrossRef]
- Ozkaya, I. Application of Large Language Models to Software Engineering Tasks: Opportunities, Risks, and Implications. IEEE Softw. 2023, 40, 4–8. [Google Scholar] [CrossRef]
- Shah, M. Deterministic vs Non-Deterministic AI: Key Differences for Enterprise Development. Augment Code, 2026. Available online: https://www.augmentcode.com/learn/deterministic-vs-non-deterministic-ai-key-differences-for-enterprise-development (accessed on 22 October 2026).
- Rahman, S. A Practical Guide to Becoming an AI-Native Engineer. ByteByteGo Newsletter. 2 June 2026. Available online: https://blog.bytebytego.com/p/a-practical-guide-to-becoming-an (accessed on 22 October 2026).
- Graziano, A. What Is AI-Native Engineering? 24 April 2026. Available online: https://alfonsograziano.it/blog/what-is-ai-native-engineering (accessed on 22 October 2026).
- Pearce, H.; Ahmad, B.; Tan, B.; Dolan-Gavitt, B.; Karri, R. Asleep at the Keyboard? Assessing the Security of GitHub Copilot’s Code Contributions. In Proceedings of the 2022 IEEE Symposium on Security and Privacy (SP), San Francisco, CA, USA, 22–26 May 2022; pp. 754–768. [Google Scholar] [CrossRef]
- Perry, N.; Srivastava, M.; Kumar, D.; Boneh, D. Do Users Write More Insecure Code with AI Assistants? In Proceedings of the 2023 ACM SIGSAC Conference on Computer and Communications Security (CCS ’23), Copenhagen, Denmark, 26–30 November 2023; pp. 2785–2799. [Google Scholar] [CrossRef]
- Spracklen, J.; Wijewickrama, R.; Sakib, A.H.M.N.; Maiti, A.; Viswanath, B.; Jadliwala, M. We Have a Package for You! A Comprehensive Analysis of Package Hallucinations by Code Generating LLMs. In Proceedings of the 34th USENIX Security Symposium, Seattle, WA, USA, 13–15 August 2025. [Google Scholar]
- Greshake, K.; Abdelnabi, S.; Mishra, S.; Endres, C.; Holz, T.; Fritz, M. Not What You’ve Signed Up For: Compromising Real-World LLM-Integrated Applications with Indirect Prompt Injection. In Proceedings of the 16th ACM Workshop on Artificial Intelligence and Security (AISec ’23), Copenhagen, Denmark, 30 November 2023; pp. 79–90. [Google Scholar] [CrossRef]
- Liu, Y.; Jia, Y.; Geng, R.; Jia, J.; Gong, N.Z. Formalizing and Benchmarking Prompt Injection Attacks and Defenses. In Proceedings of the 33rd USENIX Security Symposium, Philadelphia, PA, USA, 14–16 August 2024; pp. 1831–1847. [Google Scholar]
- Huang, J.; Chen, X.; Mishra, S.; Zheng, H.S.; Yu, A.W.; Song, X.; Zhou, D. Large Language Models Cannot Self-Correct Reasoning Yet. In Proceedings of the 12th International Conference on Learning Representations (ICLR 2024), Vienna, Austria, 7–11 May 2024. [Google Scholar]
- Panickssery, A.; Bowman, S.R.; Feng, S. LLM Evaluators Recognize and Favor Their Own Generations. In Advances in Neural Information Processing Systems 37 (NeurIPS 2024); Curran Associates: Red Hook, NY, USA, 2024. [Google Scholar]
- Zheng, L.; Chiang, W.-L.; Sheng, Y.; Zhuang, S.; Wu, Z.; Zhuang, Y.; Lin, Z.; Li, Z.; Li, D.; Xing, E.P.; Zhang, H.; Gonzalez, J.E.; Stoica, I. Judging LLM-as-a-Judge with MT-Bench and Chatbot Arena. In Advances in Neural Information Processing Systems 36 (NeurIPS 2023), Datasets and Benchmarks Track; Curran Associates: Red Hook, NY, USA, 2023. [Google Scholar]
- Parasuraman, R.; Manzey, D.H. Complacency and Bias in Human Use of Automation: An Attentional Integration. Hum. Factors 2010, 52, 381–410. [Google Scholar] [CrossRef] [PubMed]
- Goddard, K.; Roudsari, A.; Wyatt, J.C. Automation Bias: A Systematic Review of Frequency, Effect Mediators, and Mitigators. J. Am. Med. Inform. Assoc. 2012, 19, 121–127. [Google Scholar] [CrossRef] [PubMed]
- Project Management Institute. The Standard for Artificial Intelligence in Portfolio, Program, and Project Management; PMI: Newtown Square, PA, USA, 2026; Available online: https://www.pmi.org/standards/artificial-intelligence (accessed on 22 October 2026).
- PMI; Cognilytica. CPMAI Methodology Phases Overview. 2025. Available online: https://www.scribd.com/document/863497239/CPMAI-Methodology-overview (accessed on 22 October 2026).
- Claxton, L. The AI-Native SDLC Playbook. Claude Blog. 21 August 2026. Available online: https://claude.com/blog/the-ai-native-sdlc-playbook (accessed on 22 October 2026).
- Claude Academy. The AI-Native SDLC Playbook [Online Course]. Available online: https://academy.claude.com/courses/ai-native-sdlc-playbook/ (accessed on 22 October 2026).
- Learn, ChatGPT. Building an AI-Native Engineering Team. Available online: https://learn.chatgpt.com/guides/build-ai-native-engineering-team (accessed on 22 October 2026).
- Debois, P. Four Patterns of AI Native Development [Presentation]. InfoQ. 9 March 2026. Available online: https://www.infoq.com/presentations/patterns-ai-native-development/ (accessed on 22 October 2026).
- Gupta, A. Spec-Driven Development: A Spec-First Approach to AI-Native Engineering. Microsoft Dev Blogs. 10 June 2026. Available online: https://developer.microsoft.com/blog/spec-driven-development-ai-native-engineering (accessed on 22 October 2026).
- Hymel, C. The AI-Native Software Development Lifecycle: A Theoretical and Practical New Methodology. arXiv 2024, arXiv:2408.03416. [Google Scholar] [CrossRef]
- Kuhrmann, M.; Diebold, P.; Münch, J.; Tell, P.; Garousi, V.; Felderer, M.; Trektere, K.; McCaffery, F.; Linssen, O.; Hanser, E.; Prause, C.R. Hybrid Software and System Development in Practice: Waterfall, Scrum, and Beyond. In Proceedings of the 2017 International Conference on Software and System Process (ICSSP), Paris, France, 5–7 July 2017; pp. 30–39. [Google Scholar] [CrossRef]
- Gemino, A.; Horner Reich, B.; Serrador, P.M. Agile, Traditional, and Hybrid Approaches to Project Success: Is Hybrid a Poor Second Choice? Proj. Manag. J. 2021, 52, 161–175. [Google Scholar] [CrossRef]
- Scaled Agile; Inc. SAFe Big Picture (SAFe 6.0). Available online: https://framework.scaledagile.com/ (accessed on 22 October 2026).
- European Commission. PM² Agile Guide 3.0.1; Publications Office of the European Union: Luxembourg, 2021; Available online: https://op.europa.eu/en/publication-detail/-/publication/ed85debf-decc-11eb-895a-01aa75ed71a1 (accessed on 22 October 2026).
- Agile Alliance. What Is Kanban? Available online: https://agilealliance.org/glossary/kanban/ (accessed on 22 October 2026).
- Dennehy, D.; Conboy, K. Identifying Challenges and a Research Agenda for Flow in Software Project Management. Proj. Manag. J. 2018, 49, 103–118. [Google Scholar] [CrossRef]
- Solís, C.; Wang, X. A Study of the Characteristics of Behaviour Driven Development. In Proceedings of the 37th EUROMICRO Conference on Software Engineering and Advanced Applications (SEAA), Oulu, Finland, 30 August–2 September 2011; pp. 383–387. [Google Scholar] [CrossRef]
- Moradi Dakhel, A.; Majdinasab, V.; Nikanjam, A.; Khomh, F.; Desmarais, M.C.; Jiang, Z.M. GitHub Copilot AI Pair Programmer: Asset or Liability? J. Syst. Softw. 2023, 203, 111734. [Google Scholar] [CrossRef]
- Liu, J.; Xia, C.S.; Wang, Y.; Zhang, L. Is Your Code Generated by ChatGPT Really Correct? Rigorous Evaluation of Large Language Models for Code Generation. In Advances in Neural Information Processing Systems 36 (NeurIPS 2023); Curran Associates: Red Hook, NY, USA, 2023. [Google Scholar]
- Amershi, S.; Begel, A.; Bird, C.; DeLine, R.; Gall, H.; Kamar, E.; Nagappan, N.; Nushi, B.; Zimmermann, T. Software Engineering for Machine Learning: A Case Study. In Proceedings of the 41st IEEE/ACM International Conference on Software Engineering: Software Engineering in Practice (ICSE-SEIP), Montreal, QC, Canada, 25–31 May 2019; pp. 291–300. [Google Scholar] [CrossRef]
- Sculley, D.; Holt, G.; Golovin, D.; Davydov, E.; Phillips, T.; Ebner, D.; Chaudhary, V.; Young, M.; Crespo, J.-F.; Dennison, D. Hidden Technical Debt in Machine Learning Systems. In Advances in Neural Information Processing Systems 28 (NIPS 2015); Curran Associates: Red Hook, NY, USA, 2015; pp. 2503–2511. [Google Scholar]
- Kreuzberger, D.; Kühl, N.; Hirschl, S. Machine Learning Operations (MLOps): Overview, Definition, and Architecture. IEEE Access 2023, 11, 31866–31879. [Google Scholar] [CrossRef]
- Daoud, C.; Azar, D.; Urtado, C.; Vauttier, S. A Reference Architecture for an Orchestrated Collaborative MLOps: A Ground-Up Design from Literature Combining Human and LLM Expertise. Future Gener. Comput. Syst. 2026, 108700. [Google Scholar] [CrossRef]
- Cohick, J.L. Effective Developer Experience (DX). UX Magazine. 2011. Available online: https://uxmag.com/articles/effective-developer-experience (accessed on 22 October 2026).
- National Institute of Standards and Technology. Artificial Intelligence Risk Management Framework (AI RMF 1.0); NIST AI 100-1; NIST: Gaithersburg, MD, USA, 2023. [Google Scholar] [CrossRef]
- ISO/IEC 22989:2022; Information Technology—Artificial Intelligence—Artificial Intelligence Concepts and Terminology. International Organization for Standardization: Geneva, Switzerland, 2022.
- OECD. Recommendation of the Council on Artificial Intelligence; OECD: Paris, France, 2024; Available online: https://legalinstruments.oecd.org/en/instruments/OECD-LEGAL-0449 (accessed on 22 October 2026).
- High-Level Expert Group on Artificial Intelligence. Ethics Guidelines for Trustworthy AI; European Commission: Brussels, Belgium, 2019; Available online: https://digital-strategy.ec.europa.eu/en/library/ethics-guidelines-trustworthy-ai (accessed on 22 October 2026).
- Regulation (EU) 2024/1689 of the European Parliament and of the Council of 13 June 2024 Laying Down Harmonised Rules on Artificial Intelligence (Artificial Intelligence Act). Off. J. Eur. Union. 2024, L 2024/1689. Available online: http://data.europa.eu/eli/reg/2024/1689/oj (accessed on 22 October 2026).
- Lu, Q.; Zhu, L.; Xu, X.; Whittle, J.; Zowghi, D.; Jacquet, A. Responsible AI Pattern Catalogue: A Collection of Best Practices for AI Governance and Engineering. ACM Comput. Surv. 2024, 56, 173. [Google Scholar] [CrossRef]
- Raji, I.D.; Smart, A.; White, R.N.; Mitchell, M.; Gebru, T.; Hutchinson, B.; Smith-Loud, J.; Theron, D.; Barnes, P. Closing the AI Accountability Gap: Defining an End-to-End Framework for Internal Algorithmic Auditing. In Proceedings of the 2020 Conference on Fairness, Accountability, and Transparency (FAT* ’20), Barcelona, Spain, 27–30 January 2020; pp. 33–44. [Google Scholar] [CrossRef]
- Ji, Z.; Lee, N.; Frieske, R.; Yu, T.; Su, D.; Xu, Y.; Ishii, E.; Bang, Y.J.; Madotto, A.; Fung, P. Survey of Hallucination in Natural Language Generation. ACM Comput. Surv. 2023, 55, 248. [Google Scholar] [CrossRef]
- Schmitt, J. Risks and Rewards of Generative AI for Software Development. CircleCI Blog. 2024. Available online: https://circleci.com/blog/risks-rewards-generative-ai/ (accessed on 22 October 2026).
- Mosqueira-Rey, E.; Hernández-Pereira, E.; Alonso-Ríos, D.; Bobes-Bascarán, J.; Fernández-Leal, Á. Human-in-the-Loop Machine Learning: A State of the Art. Artif. Intell. Rev. 2023, 56, 3005–3054. [Google Scholar] [CrossRef]
- Shneiderman, B. Human-Centered Artificial Intelligence: Reliable, Safe & Trustworthy. Int. J. Hum.–Comput. Interact. 2020, 36, 495–504. [Google Scholar] [CrossRef]
- Parasuraman, R.; Sheridan, T.B.; Wickens, C.D. A Model for Types and Levels of Human Interaction with Automation. IEEE Trans. Syst. Man. Cybern. Part A Syst. Hum. 2000, 30, 286–297. [Google Scholar] [CrossRef] [PubMed]
- Hevner, A.R.; March, S.T.; Park, J.; Ram, S. Design Science in Information Systems Research. MIS Q. 2004, 28, 75–105. [Google Scholar] [CrossRef]
- Wieringa, R.J. Design Science Methodology for Information Systems and Software Engineering; Springer: Berlin/Heidelberg, Germany, 2014. [Google Scholar] [CrossRef]
- Peffers, K.; Tuunanen, T.; Rothenberger, M.A.; Chatterjee, S. A Design Science Research Methodology for Information Systems Research. J. Manag. Inf. Syst. 2007, 24, 45–77. [Google Scholar] [CrossRef]
- Engström, E.; Storey, M.-A.; Runeson, P.; Höst, M.; Baldassarre, M.T. How Software Engineering Research Aligns with Design Science: A Review. Empir. Softw. Eng. 2020, 25, 2630–2660. [Google Scholar] [CrossRef]
- Venable, J.; Pries-Heje, J.; Baskerville, R. FEDS: A Framework for Evaluation in Design Science Research. Eur. J. Inf. Syst. 2016, 25, 77–89. [Google Scholar] [CrossRef]
- Runeson, P.; Höst, M. Guidelines for Conducting and Reporting Case Study Research in Software Engineering. Empir. Softw. Eng. 2009, 14, 131–164. [Google Scholar] [CrossRef]
- OpenAI Developers. Prompting. Available online: https://developers.openai.com/api/docs/guides/prompting (accessed on 22 October 2026).
- NB, A. Understanding Retrieval Pipelines: How AI Finds and Uses Relevant Information. Medium. 10 April 2026. Available online: https://medium.com/@aryanbkrishnan/understanding-retrieval-pipelines-how-ai-finds-and-uses-relevant-information-41b6710d379f (accessed on 22 October 2026).
- McGrath, A.; Jonker, A. What Is AI Safety? IBM Think. 15 November 2024. Available online: https://www.ibm.com/think/topics/ai-safety (accessed on 22 October 2026).
- Natarajan, M. Understanding Pair Prompting in AI. testRigor, 2026. Available online: https://testrigor.com/blog/pair-prompting-in-ai/ (accessed on 22 October 2026).
- Floridi, L. The Fight for Digital Sovereignty: What It Is, and Why It Matters, Especially for the EU. Philos. Technol. 2020, 33, 369–378. [Google Scholar] [CrossRef] [PubMed]
- Wohlin, C.; Runeson, P.; Höst, M.; Ohlsson, M.C.; Regnell, B.; Wesslén, A. Experimentation in Software Engineering; Springer: Berlin/Heidelberg, Germany, 2012. [Google Scholar] [CrossRef]
Figure 1.
Evidential independence: admissibility of evidence as a function of evidence strength and change severity. Above the diagonal, evidence is admissible (adm(e,s) = True). The two points illustrate insufficient (2.0) and sufficient (4.5) evidence for a change of severity 4.
Figure 1.
Evidential independence: admissibility of evidence as a function of evidence strength and change severity. Above the diagonal, evidence is admissible (adm(e,s) = True). The two points illustrate insufficient (2.0) and sufficient (4.5) evidence for a change of severity 4.

Table 1.
Positioning of IntDEx relative to adjacent approaches.
| Approach | Primary concern | What IntDEx reuses | What IntDEx adds |
|---|---|---|---|
| Spec-driven development, BDD [23,31] | Executable specification as durable asset | Specification layer, behaviour scenarios | Versioned intent with human-validated acceptance criteria before implementation; blocking intent-change checkpoint |
| AI-native SDLC playbooks [5,19] | Stage-level workflow patterns | Agent workflows, context files, evaluation sets | Enforcement classes, decision records, admissible-evidence hierarchy |
| V-Bounce model [24] | AI as implementation engine with phase reviews | AI-led implementation, human review per phase | Role model and RACI, separation of engine from solution, evidential independence, practical application |
| Project/product methods [17,27,28] | Portfolio and organisational governance | Hybrid governance, strategic cadence | Flow-based, readiness-triggered delivery; unified product delivery management |
| DevSecOps | Deterministic delivery controls | CI/CD gates, scanning, SBOM | Use of deterministic checks as executed evidence for AI-generated artefacts |
| MLOps/LLMOps [36,37] | Model and runtime operations | Model registries, monitoring, drift detection | Monitoring of the delivery engine itself as a step that can also create input to delivery |
Table 2.
Realisation of the DSR activities [53] in this study.
Table 2.
Realisation of the DSR activities [53] in this study.
| DSR activity | Realisation in this study |
|---|---|
| Problem identification and motivation | Delivery needs of a research project requiring rapid construction of a data-science platform; gaps in AI-native lifecycle proposals (Section 2) |
| Objectives of a solution | Design objectives derived from RQ1–RQ4: governed end-to-end delivery, enforceable human oversight, independent evidence, reproducibility from artefacts, regulatory and sovereignty awareness |
| Design and development | Iterative construction of IntDEx alongside platform development; literature integrated at each iteration |
| Demonstration | Use of IntDEx to deliver the platform and its support tools (Section 3.3) |
| Evaluation | Three evaluation actions: reconstruction from artefacts against an intent-only baseline (E1), enforced checkpoint records (E2), cross-model review records (E3) (Section 3.4) |
| Communication | This article, the Supplementary Materials and the versioned framework with its issue log |
Table 3.
Defining characteristics of IntDEx and their engineering consequences.
| Characteristic | Meaning in IntDEx | Engineering consequence |
|---|---|---|
| Non-linear | Intents, prompts, models, constraints, data and oversight influence each other continuously; fast intermediate results dissolve phase boundaries [40] | A continuous intelligence loop in which any phase can trigger a return to any other. Flow-based delivery [30] |
| Emergent | Engine and solution behaviour arises from the interaction of prompts, models, context and oversight and cannot be fully pre-determined | Emergence is treated as a defining property and a source of insight rather than an anomaly |
| Behaviour-driven | The solution is defined by observable behaviour | Acceptance shifts from code or strict and detailed designs to behaviour. |
| Intent-centric | Intent, AI-drafted and human-validated, is the primary specification [23,57] | Intent can replace user stories as the stable reference for validation and monitoring |
| Context- and constraint-dependent | Behaviour depends on the context supplied at runtime, e.g., through retrieval pipelines [58] | Context is a governed and cost-managed resource with recorded provenance |
| Model-adaptive | Models evolve, drift and differ in capability [22] | Models are interchangeable components evaluated for fitness; routing adapts to quality, cost and latency |
| Human-augmented with evidential independence | AI extends human capacity; humans keep decision authority [59] | Enforceable checkpoints and admissible-evidence rules (Paragraphs 4.4 and 4.5) |
Table 4.
The seven IntDEx delivery phases.
| Phase | Purpose | Key outputs | Decision owner |
|---|---|---|---|
| 1. Intent definition | Establish behavioural goals, constraints and acceptance criteria in domain language | Versioned intents, constraints, contexts, acceptance criteria confirmed before implementation | Human (blocking checkpoint) |
| 2. Delivery-engine architecture | Design the engine: models, routing, retrieval, safeguards, enforcement boundaries | Engine configuration, mandatory instruction artefacts, sovereignty constraint records | Human (Architect; DM accepts) |
| 3. Generative creation | Generate and refine behaviour through prompts and models instead of manual coding | Versioned prompts, behaviour prototypes, Deterministic Data | Shared: human directs, engine produces |
| 4. Behaviour validation | Validate correctness, safety, bias, hallucination and constraint compliance | Validated behaviours with evidence classified by source/practice | Human; engine self-report is UNVERIFIED |
| 5. Deployment and release | Release on a readiness signal with full traceability | Behavioural release bundle, tested rollback path | Human (BO/DM release approval) |
| 6. Continuous monitoring | Detect drift, degradation, cost, security and sovereignty deviations of the engine | Monitoring signals that trigger new delivery cycles | Shared detection, human judgement |
| 7. Behaviour evolution | Replace maintenance with governed evolution of solution and engine behaviour | Updated intents and versioned baselines for regression detection | Human for intent, engine for implementation |
Table 5.
Reconstruction outcomes: original solution, intent-only baseline and IntDEx artefact-based reconstruction.
Table 5.
Reconstruction outcomes: original solution, intent-only baseline and IntDEx artefact-based reconstruction.
| Property | Original solution | Baseline B0 (intent only) | IntDEx reconstruction |
|---|---|---|---|
| Authoring model | GPT-5.3-Codex | Claude Opus 5 | Claude Opus 5 |
| Input | Iterative delivery under IntDEx | Major initial intent | IntDEx artefacts, no source code |
| Codebase size | 52,598 LOC | ≈11,000 LOC | |
| Working system | Yes | No | Yes |
| Route-surface similarity | Reference | Not measurable | ≈95% of tested URL patterns and user journeys |
| Runs | – | 1 | 1 |
Table 6.
Observed deviations of the IntDEx reconstruction by reproducibility dimension.
| Dimension | Observation |
|---|---|
| Behaviour (route surface) | ≈95% of tested routes and journeys equivalent |
| Architecture and configuration | Different file names and project structure |
| Data structures and migrations | Different database tables and columns |
| Security | Weaker input validation, sanitisation, rate limiting and human-verification controls |
| Operational capabilities | No major deviation reported |
| Delivery-engine configuration | Engine configuration recorded and retained for further runs |
Table 7.
Effect of enforced human oversight and cross-model review.
| Episode | Population | Events | Consequential outcomes |
|---|---|---|---|
| E2 – Mandatory checkpoints | 17 major checkpoints | 7 outcome changes | 3 halts (insufficient engine evidence); 4 severity reclassifications |
| E3 – Cross-model review (XMOD) | >70 prompt executions | 19 deviations from authoring model | 4 human-confirmed changes not detectable by self-assessment |
Table 8.
Measurement agenda for comparative evaluation.
| Dimension | Suggested measure |
|---|---|
| Speed | Change lead time, active AI time, human waiting time |
| Human burden | Review minutes, checkpoints per accepted change, approval/rejection/rework |
| Quality | First-pass acceptance, escaped defects, behavioural regression |
| Security | Findings before release, escaped findings, blocked unsafe transitions |
| Evidence | Share of production claims backed by independent evidence |
| Cost | Provider-measured AI cost per accepted delivery transaction |
| Reconstruction | Behavioural, security, data, configuration and operational equivalence |
| Portability | Successful provider/model migration exercise and effort |
| Governance | Exception count and age, negative-control-test pass rate |
Disclaimer/Publisher’s Note: The statements, opinions and data contained in all publications are solely those of the individual author(s) and contributor(s) and not of MDPI and/or the editor(s). MDPI and/or the editor(s) disclaim responsibility for any injury to people or property resulting from any ideas, methods, instructions or products referred to in the content. |
© 2026 by the authors. Licensee MDPI, Basel, Switzerland. This article is an open access article distributed under the terms and conditions of the Creative Commons Attribution (CC BY) license (http://creativecommons.org/licenses/by/4.0/).
Copyright: This open access article is published under a Creative Commons CC BY 4.0 license, which permit the free download, distribution, and reuse, provided that the author and preprint are cited in any reuse.