AI in the SDLC: Overcoming Technical, Organizational, and Ethical Obstacles

Last updated: 29 October 2026

AI in SDLC Software Engineering Curated Review

Moving Beyond the Hype: The Realities of AI in Modern Software Engineering

Over the past three years, the narrative surrounding artificial intelligence in software engineering has been dominated by extreme declarations. On one side, corporate marketing departments celebrate autonomous coding agents capable of synthesizing enterprise web services from simple natural language prompts. On the other side, engineering leaders and system architects confront a markedly more frustrating reality: despite heavy investments in seat licenses for neural code assistants, overall delivery velocity often plateaus, repository pull requests become clogged with difficult-to-review boilerplate, and unexpected regressions plague deployment pipelines.

This profound disconnect stems from a fundamental conceptual mistake: confusing isolated task automation with systemic lifecycle integration. Writing a single function or completing a regex pattern inside an integrated development environment (IDE) is a localized, bounded action. In contrast, the Software Development Life Cycle (SDLC) is an interconnected, sociotechnical system spanning ambiguous business requirements, complex architectural tradeoffs, legacy dependency graphs, multi-stage verification gates, and long-term production maintenance. Introducing machine intelligence into one phase without addressing its ripple effects across the rest of the chain inevitably produces bottlenecks elsewhere.

To understand how technical teams can move beyond commercial slogans and achieve genuine, sustainable improvements in engineering throughput, we must turn to rigorous empirical scholarship. A seminal contribution to this discourse is provided by Marcela Paladino and Claudia Pons in their peer-reviewed research article, titled "From Obstacles to Strategies: Integrating Artificial Intelligence into the Software Development Life Cycle". Originating from the LIFIA research laboratory within the Universidad Nacional de La Plata (UNLP) and presented at the 54th Argentine Conference on Informatics (JAIIO), their research represents one of the most comprehensive curated reviews of modern AI tooling, structural failure modes, and recovery frameworks in contemporary software engineering literature.

"Although deep learning, natural language processing, and intelligent agents offer immense opportunities to optimize planning, requirements, coding, testing, and operations, persistent barriers in data quality, legacy architectures, organizational culture, and model opacity severely restrict full adoption. Overcoming these hurdles demands combining technical data engineering with deep human upskilling and unyielding ethical oversight."

Rather than evaluating artificial intelligence as an isolated theoretical discipline, Paladino and Pons's study systematically maps the state of practice across thirty-two foundational software engineering studies published between 2022 and 2025. In this long-form research roundup, we explore the core findings of their work, analyzing the specific technologies deployed across each lifecycle phase, diagnosing the hidden friction points that derail adoption, and detailing their actionable three-tier blueprint for building resilient, AI-augmented engineering organizations.

Methodological Architecture: How the Empirical Evidence Was Curated

To ensure that their findings reflected verifiable industry evidence rather than speculative commentary, Paladino and Pons executed a structured narrative review methodology with explicit filtering protocols. The research surveyed leading international scientific databases, including IEEE Xplore, Scopus, ACM Digital Library, Web of Science, and Google Scholar, utilizing targeted Boolean combinations of terms such as ("artificial intelligence" OR "machine learning" OR "deep learning" OR "NLP") AND ("software development life cycle" OR "SDLC") AND ("integration" OR "challenges" OR "strategies").

Crucially, the authors accounted for both global English-language publications and Latin American software engineering literature, reviewing studies documented across both international symposiums and regional venues. Each retrieved paper was scrutinized against five stringent quality appraisal criteria:

The Five Research Evaluation Criteria Applied

  • 1. Clarity of Scope and Objectives: The publication had to formulate explicit, verifiable research questions directly assessing AI tools or techniques within specific software lifecycle phases.
  • 2. Methodological Soundness: The underlying research design—whether an empirical software engineering experiment, an industrial case study, or a developer survey—had to exhibit coherent, transparent data collection protocols.
  • 3. Empirical Reproducibility: The models, parameter settings, evaluation benchmarks, or repository datasets had to be described with sufficient detail to allow external academic or industrial verification.
  • 4. Validity and Defensibility of Findings: Findings had to account for confounding variables, baseline software metrics, and statistical significance, avoiding unverified promotional claims.
  • 5. Pragmatic Engineering Value: The work had to provide concrete architectural, procedural, or organizational insights directly applicable to practicing software teams.

The centerpiece of the study was a comprehensive data extraction matrix. For every qualifying publication, the authors cataloged five core attributes: the specific SDLC phase addressed, the specific AI technologies applied, the technical or organizational obstacles encountered, the proposed mitigation strategies, and the measurable impact on software quality or team efficiency. As highlighted in the research article, this structured matrix transformed an unwieldy collection of heterogeneous studies into an organized, comparative taxonomy of the global software engineering landscape.

The review's methodological analysis also exposed a critical industry distortion: academic and corporate publications demonstrate a severe asymmetry in research focus. Over sixty percent of published literature concentrates narrowly on code implementation and automated test case synthesis. In contrast, foundational phases such as requirements engineering, architectural planning, and long-term legacy maintenance remain under-researched, despite accounting for more than seventy percent of total software project budgets and post-release defect costs.

Taxonomy of AI Across the Eight Lifecycle Phases

One of the most valuable aspects of the review is its granular, phase-by-phase breakdown of modern AI tooling. Paladino and Pons dismantle the common misconception that "AI in software engineering" simply means generative large language models (LLMs) writing code. Across the eight classic phases of the software development lifecycle, engineering teams deploy a diverse array of machine learning paradigms, from computer vision to recurrent neural networks and reinforcement learning.

1. Project Planning & Estimation

In the earliest stage of development, accurate estimation of effort, schedule, and team capacity is essential for project viability. The literature highlights the use of Optical Character Recognition (OCR) systems to digitize unstructured client documentation, historical RFPs, and architectural diagrams. These digitized inputs are fed into deep learning regression networks to estimate Function Points and COCOMO parameters (Benitez & Serrano, 2023). In parallel, Long Short-Term Memory (LSTM) recurrent neural networks analyze past sprint completion logs and burndown charts to forecast velocity under fluctuating team constraints (Kumar, 2024), while workflow engines like Jira Automation assist managers in dynamically distributing backlog tickets.

2. Requirements Elicitation & Engineering

Software defects originate most expensively in ambiguous or contradictory requirements. Natural Language Processing (NLP) pipelines, powered by transformer models, parse conversational interview transcripts, customer support requests, and user feedback to extract formal, structured user stories (Garg, 2023). Semantic parsers compare newly drafted specifications against existing domain ontologies, automatically flagging scope creep, missing boundary conditions, and semantic ambiguities before engineering teams write a single line of design (Siddique, 2022).

3. Architectural Analysis & Feasibility

During the analysis phase, systems engineers must evaluate whether proposed feature sets violate non-functional constraints such as latency, security, or throughput. The review highlights machine learning models that analyze historical vulnerability databases (such as CVE repositories) to predict architectural hotspots susceptible to security exploits (Durrani et al., 2024). Multi-objective optimization algorithms evaluate proposed component partitioning, balancing database read-write latency against microservice network overhead (Giffari et al., 2024).

4. Architectural Design & Prototyping

In software design, computer vision and generative models have dramatically accelerated the path from conceptual ideation to functional prototypes. Computer vision tools such as Microsoft's Sketch2Code transform hand-drawn whiteboard wireframes directly into semantic HTML and CSS layouts (Upadhyaya, 2022). Generative UX design assistants synthesize complete interface flows in tools like Adobe XD and Figma, while architectural assistants like ArchiMate AI assist senior engineers in mapping microservice communication topologies and verifying compliance with enterprise architecture standards (Keskar, 2023; Kokol, 2024).

5. Implementation & Code Generation

The implementation stage represents the most commercially mature application of AI. Generative code models such as GitHub Copilot, OpenAI Codex, and Anthropic Claude draft routine boilerplate, synthesize database queries, and auto-complete complex algorithmic routines directly inside developer editors (Müller, 2024). Beyond autocomplete, neural transpilers such as Facebook TransCoder translate legacy languages (like COBOL, C++, or Fortran) into modern Java or Python syntaxes by learning unsupervised cross-lingual mappings across Abstract Syntax Trees (ASTs) (Özpolat et al., 2023).

6. Testing & Quality Assurance

AI-driven testing moves software verification beyond static scripts. Deep learning test generators analyze commit diffs to synthesize targeted unit test cases and boundary-condition assertions (Shah & Trehan, 2024). Autonomous visual regression platforms such as Applitools, Testim, and Test.AI use computer vision to detect subtle UI misalignments and layout breaks across hundreds of mobile device viewports without requiring fragile manual element selectors (Medepalli, 2025; Khan et al., 2023).

7. Deployment & CI/CD Pipelines

Within Continuous Integration and Continuous Deployment (CI/CD) pipelines, intelligent agents optimize the execution of extensive test matrices. Reinforcement learning algorithms dynamically reorder test execution suites, prioritizing test cases most likely to fail based on commit author, changed files, and code churn metrics (Kambala, 2024). AI-augmented delivery pipelines predict deployment failures before release, automatically rolling back staging environments and orchestrating container resource allocation on Kubernetes clusters (Vadde & Munagandla, 2022).

8. Maintenance & Operational Evolution

During the post-deployment maintenance phase—which consumes the majority of enterprise software lifecycle budgets—observability platforms like Dynatrace, New Relic, and Datadog leverage unsupervised anomaly detection to identify memory leaks, database connection pool exhaustion, and network bottlenecks hours before users experience latency degradations (Ajiga et al., 2024). Concurrently, semantic refactoring agents analyze monolithic code repositories to detect architectural code smells, cyclic dependencies, and dead code, suggesting automated refactoring pull requests (Haghsheno, 2020).

SDLC Stage Core Technologies Primary Engineering Function Key Empirical Studies
Planning OCR, LSTM Networks, Deep Regressors Effort estimation, velocity forecasting, resource sizing Benitez & Serrano (2023), Kumar (2024)
Requirements NLP Transformers, Semantic Parsers Ambiguity reduction, user story structuring, consistency audits Garg (2023), Siddique (2022)
Analysis OCR text mining, ML Vulnerability Models Defect hotspot anticipation, domain constraint validation Durrani et al. (2024), Giffari et al. (2024)
Design Sketch2Code, ArchiMate AI, Generative UI Wireframe to code synthesis, architectural simulation Upadhyaya (2022), Kokol (2024)
Implementation GitHub Copilot, Codex, Facebook TransCoder Contextual code completion, AST transpilation, linting Müller (2024), Özpolat et al. (2023)
Testing Testim, Applitools, Deep Test Synthesis Visual regression sweeps, unit test suite generation Shah & Trehan (2024), Medepalli (2025)
Deployment Reinforcement Learning, Autonomous CI/CD Dynamic test suite prioritization, self-healing rollbacks Kambala (2024), Vadde & Munagandla (2022)
Maintenance Dynatrace, New Relic, Semantic Refactoring Telemetry anomaly detection, proactive technical debt repair Ajiga et al. (2024), Haghsheno (2020)

This taxonomy demonstrates that modern AI is not a singular silver bullet, but a rich matrix of specialized, phase-specific computational tools. However, identifying available tools is only half the battle. As Paladino and Pons emphasize throughout their review, the true barrier to engineering success is not the absence of algorithms, but the systemic friction encountered when attempting to knit these tools into cohesive production environments.

The Critical Asymmetry: Why Planning, Testing, and Maintenance Fail First

A central empirical finding synthesized in the research article is that adoption friction does not distribute evenly across the development cycle. Instead, software organizations experience severe, disproportionate resistance at three specific stages: Planning, Testing & Quality Assurance, and Deployment & Maintenance.

Why does the coding phase appear so effortless while planning and maintenance stall? The answer lies in the nature of computational feedback loops. In the implementation phase, developers work in tightly bounded environments governed by compilers, typecheckers, and linters. If an AI model generates invalid syntax or hallucinated variables, the compiler immediately rejects the code. The developer sees the error, edits the prompt, and moves forward. The feedback is deterministic and instant.

In stark contrast, planning, testing, and maintenance operate under open-world uncertainty where automated deterministic checks are fundamentally absent:

1. Planning Bottlenecks

Predictive estimation models rely on historical project data. In most enterprises, Jira tickets and git commits are notoriously messy: developers omit story points, fail to log actual hours, or shift requirements informally over chat. When models ingest noisy data, their timeline projections fail catastrophically.

2. The Test Oracle Problem

Neural test generators can create thousands of unit tests in seconds. However, verifying whether the generated assertion represents correct business intent requires deep human domain expertise. Generating high test coverage without correct oracles provides dangerous, deceptive security.

3. Legacy Monoliths

Modern AI observability and self-healing tools presuppose observable, containerized microservices. In reality, enterprise production still runs on monolithic codebases with global state mutations, where unmonitored automated patches trigger catastrophic cascading regressions.

This asymmetry explains why technical executives frequently report disappointment with enterprise AI initiatives. By spending millions on developer code-completion licenses while ignoring the data quality required for planning and the human validation required for test assertions, organizations accelerate code production only to create massive traffic jams in quality assurance and staging environments.

The Technical Triad: Data Quality, Algorithmic Opacity, and Legacy Drift

Beneath the organizational friction lies a triad of hard technical barriers that prevent artificial intelligence from operating reliably in mission-critical environments. In her data extraction matrix, Paladino classifies these barriers into three interrelated technical categories: Data Fragmentation, Model Opacity, and Shadow Technical Debt.

1. Data Quality and the "Garbage In, Garbage Out" Trap

Supervised machine learning and predictive deep neural networks require vast, accurately labeled datasets. Yet, across real-world enterprise repositories, data hygiene is exceptionally poor. Version control logs are filled with uninformative commit messages such as "fixed bug", "wip", or "updates." Issue trackers suffer from duplicate tickets, missing reproduction steps, and arbitrary priority classifications. When predictive models are trained on these fragmented, unstructured histories, they learn spurious correlations rather than true causal relationships, leading to erratic defect predictions and unreliable resource forecasts.

2. Algorithmic Opacity: The Black-Box Dilemma

Modern deep learning architectures and large language models function as probabilistic black boxes. They generate answers without providing verifiable logical derivations or causal justifications (Özpolat et al., 2023; Müller, 2020). In safety-critical software sectors—such as medical devices, automotive control systems, aerospace avionics, and banking platforms—engineers cannot deploy code or architectural changes that cannot be explained or formally audited. When an AI tool recommends deprecating a database index or altering an authentication handshake, architects cannot accept the modification based on algorithmic confidence scores alone.

3. Hallucinations and Shadow Technical Debt

While generative code models draft syntax rapidly, they are fundamentally predictive next-token systems, not symbolic reasoning engines. Consequently, they routinely hallucinate non-existent API parameters, invoke deprecated library functions, or introduce subtle concurrency and memory safety defects that pass unit test compilation. When software engineers accept synthetic boilerplate without thorough, line-by-line semantic inspection, the repository accumulates shadow technical debt. Over successive development iterations, this unvetted code fragments system architecture and creates nightmarish debugging sessions when original authors cannot decipher synthetic code generated months earlier.

Common Failure Modes in AI-Generated Codebases

  • • Phantom Dependencies: Recommending third-party packages that do not exist, exposing projects to supply-chain package-squatting attacks.
  • • Subtle Boundary Violations: Overlooking off-by-one errors and unchecked null pointer exceptions in asynchronous promise handling.
  • • Architectural Incoherence: Introducing inconsistent design patterns across microservice boundaries, destroying repository cohesion.

The Human Dynamic: Cultural Resistance, Skill Atrophy, and Executive Disconnect

Technical obstacles do not exist in an organizational vacuum. Software engineering remains an intensely human, collaborative discipline. Paladino and Pons's synthesis underscores that psychological resistance and cultural friction present hurdles just as formidable as algorithmic limitations.

When organizations introduce automated tooling without clear, empathetic change management, developers experience acute anxiety regarding job security and professional obsolescence (Haghsheno, 2020; Alenezi & Akour, 2025). Senior software engineers, whose identities and authority have been built over decades of mastering difficult syntaxes and architectural patterns, often exhibit justified skepticism toward automated tools that produce unverified code. Without structured organizational support, this skepticism curdles into passive resistance, where developers bypass official tools in favor of familiar manual workflows.

The Danger of Cognitive Atrophy

Junior engineers who rely excessively on AI copilots risk skipping the vital cognitive struggle of mental debugging. Without wrestling with compiler errors and tracing memory pointers manually, early-career developers fail to build deep mental models of system behavior, leaving teams vulnerable when critical production outages require low-level systems triage.

The Executive Expectation Gap

Corporate leadership often expects instantaneous head-count reductions following AI tool rollouts. This reflects a profound misunderstanding: AI does not eliminate engineering work; it elevates developer focus from syntax typing to rigorous specification, architectural partitioning, security auditing, and verification harness design.

A related organizational barrier is the persistent cultural divide between data scientists and software engineering squads. Machine learning specialists operate primarily in exploratory Jupyter notebooks optimizing statistical loss metrics, while core backend engineers care about API latency, zero-downtime database migrations, and backward compatibility. When organizations fail to build cross-functional bridges between these groups, AI models remain isolated research prototypes that fail to survive production deployment.

Ethics, Transparency, and Legal Governance in AI Engineering

In traditional software development, ethical considerations and regulatory compliance were frequently treated as post-hoc policy matters handled by legal departments. In an AI-augmented lifecycle, Paladino and Pons argue that ethics, data privacy, and intellectual property provenance must become first-class engineering requirements embedded directly into continuous integration quality gates.

The primary legal hazard stems from intellectual property contamination. Large language models trained on public internet repositories frequently memorize and reproduce copyrighted code or open-source libraries licensed under restrictive copyleft terms, such as GNU General Public License (GPL) (Todorov, 2022; Russo, 2024). When an enterprise engineer unknowingly merges an AI-generated snippet containing verbatim GPL-licensed logic into a proprietary commercial product, the entire codebase risks severe legal exposure and licensing disputes.

Core Governance Pillars Identified in the Monograph

  • • Data Confidentiality and IP Leakage: Cloud-hosted developer assistants transmit proprietary code schemas and API keys to third-party model providers. Organizations must mandate zero-retention enterprise agreements or deploy self-hosted open-weights models within private virtual clouds.
  • • Algorithmic Bias in Project Governance: Predictive ticket triaging and developer allocation algorithms can easily encode historical managerial biases, unfairly penalizing specific engineers or misallocating resources away from critical maintenance tasks.
  • • Regulatory Compliance Mandates: Global regulations—such as the European Union AI Act and ISO/IEC 42001—require rigorous risk assessments, reproducible training audit trails, and mandatory human accountability for autonomous decision systems in software applications.

The research makes clear that ethical engineering is not an optional marketing virtue; it is an essential risk management discipline. Without automated license scanning and rigorous human accountability protocols, software organizations expose themselves to devastating copyright litigation and regulatory penalties.

Empirical Case Evidence: What Works and What Fails in Real-World Pipelines

In Section 4.3.6 of their comprehensive study, Paladino and Pons ground their theoretical analysis in concrete empirical field reports from production software teams. Analyzing these case studies provides critical guidance on what genuinely functions in production environments versus what fails under operational load.

In continuous delivery environments, investigations by Kambala (2024) and Alford (2019) evaluated the deployment of intelligent software agents to orchestrate CI/CD pipelines. These autonomous agents analyzed commit diffs, dynamically scheduled test suites, and allocated cloud compute resources. While teams experienced a thirty-five percent reduction in total build cycle times, the authors noted that legacy build servers required extensive custom middleware adapters to communicate with agent protocols, and unmonitored test re-ordering occasionally masked flaky integration tests.

In requirements engineering, research by Garg (2023) and Upadhyaya (2022) examined the use of NLP models to parse conversational client transcripts and support tickets. The models successfully categorized customer requests and reduced requirement ambiguities by approximately thirty percent. However, the authors underscored that human systems analysts had to perform rigorous final sign-offs: whenever the NLP models attempted to generate formal acceptance criteria without human review, they consistently hallucinated invalid domain constraints.

Automated QA Benchmarks

Benitez & Serrano (2023) and Khan et al. (2023) revealed that deep learning unit generators accelerated test creation by forty percent, but required dedicated test engineers to curate assertions and prevent test suite bloat from driving up cloud compute costs.

Predictive Telemetry Benchmarks

Field research by Müller (2024) and Ajiga et al. (2024) demonstrated that machine learning anomaly detectors in enterprise cloud environments reduced unplanned downtime by twenty-five percent through early identification of memory leaks.

The universal takeaway across all documented case studies is clear: AI achieves remarkable success when deployed as an assistive, bounded tool under explicit human verification gates. Whenever organizations attempted to give models unmonitored autonomy over architecture, code merges, or deployment decisions, defect escape rates spiked, forcing teams to roll back automation.

The Three-Tier Strategy Framework for Sustainable Enterprise Adoption

To bridge the gap between algorithmic potential and production reality, Paladino and Pons synthesize their findings into an actionable, three-tier strategic framework. Detailed in their research article, this model provides engineering leaders with a holistic blueprint covering technical infrastructure, organizational capability, and ethical governance.

Tier 1: Technical Infrastructure — Data Curation, Explainability, and Modularity

Organizations must treat internal repository data as a core software asset. This requires establishing strict commit message standards, automating issue ticket linking, and constructing dedicated data cleansing pipelines to filter out noisy legacy records before training predictive estimation engines. Furthermore, teams must invest in Explainable AI (XAI) frameworks, utilizing attention heatmaps and hybrid rule-based wrappers so developers can inspect the underlying rationale behind model recommendations.

For legacy codebases, architects must abandon risky "big-bang" rewrites. Instead, they should build modular abstraction facades and API wrappers around monolithic components, allowing modern AI-assisted microservices to interface cleanly without destabilizing core business transactions (Kambala, 2024; Vadde & Munagandla, 2022).

Tier 2: Organizational Capability — Continuous Upskilling and Cross-Functional Squads

Overcoming developer resistance requires structured, continuous learning programs. Developers must be trained in prompt engineering, automated code review verification, and algorithmic vulnerability auditing. Engineering managers must foster psychological safety, explicitly rewarding developers who identify and reject flawed AI recommendations rather than evaluating engineers on superficial metrics like lines of code accepted.

Additionally, enterprises should form cross-functional pods that co-locate machine learning specialists, systems architects, and QA engineers. This ensures that algorithmic solutions are evaluated against production latency, backward compatibility, and maintainability rather than isolated academic metrics.

Tier 3: Ethical & Governance Policy — Privacy Audits and Human Accountability

Enterprise governance demands institutionalizing strict data protection and intellectual property protocols. Engineering leadership must mandate zero-retention enterprise agreements with external tool vendors or host self-contained open-weights models on private infrastructure. Automated CI/CD gates should continuously scan code diffs for GPL license contamination, known CVE vulnerability signatures, and hardcoded secrets.

Above all, organizations must enforce an inviolable human-in-the-loop principle (Todorov, 2022; Russo, 2024). AI systems may draft, summarize, and explore, but licensed human software engineers must review, validate, and assume ultimate professional and legal liability for every merged line of production code.

Actionable AI Integration Checklist for Engineering Leaders

• Sanitize Repository Telemetry: Standardize commit metadata and bug tagging before training predictive planning models.

• Mandate Human Code Reviews: Require dual-engineer approvals for all pull requests containing AI-generated code or automated test fixtures.

• Secure Intellectual Property: Block public API endpoints on developer workstations and deploy private, zero-retention model gateways.

• Automate License Audits: Integrate real-time open-source license scanning into CI/CD pipelines to prevent copyleft contamination.

• Measure Meaningful Metrics: Track change failure rates, mean time to recovery (MTTR), and developer flow state rather than raw code volume generated.

Methodological Boundaries and Future Research Frontiers

In Section 5.6 of their thesis, Paladino and Pons openly discuss the methodological boundaries of their review, providing engineers with necessary perspective when applying these insights.

First, as a structured narrative review rather than a rigid PRISMA-compliant quantitative meta-analysis, the synthesis relies on qualitative interpretation and purposeful study selection. While this format allows the authors to weave complex technical, cultural, and ethical dynamics into a unified narrative, it inevitably carries selection subjectivity. Specialized proprietary tools or non-indexed enterprise case studies may not be represented.

Second, the velocity of artificial intelligence tooling presents an ongoing challenge. The literature reviewed spans 2022 through early 2025, capturing the rapid evolution from narrow task classifiers to foundation models and conversational coding copilots. However, the subsequent emergence of multi-agent development frameworks, extended context windows exceeding millions of tokens, and deep IDE agentic protocols continues to alter developer workflows. Technical leaders must treat Paladino and Pons's work not as a static catalog of ephemeral products, but as an enduring architectural and governance framework.

Looking toward future frontiers, the authors highlight three pressing areas for software engineering scholarship: neuro-symbolic code generation that combines neural flexibility with formal mathematical verification proofs, automated multi-agent peer review systems that model team interaction dynamics, and standardized enterprise benchmark suites for evaluating AI code quality on multi-million-line legacy codebases.

Frequently Asked Questions

What is the central thesis of Marcela Paladino and Claudia Pons's research?

The central thesis is that artificial intelligence tools exist across all eight software development life cycle phases, but their successful enterprise adoption is constrained by dirty repository data, opaque model reasoning, legacy system incompatibility, organizational resistance, and legal-ethical liabilities. Overcoming these barriers requires a coordinated three-tier strategy combining technical data curation, continuous developer education, and robust ethical governance.

Which software life cycle phases present the steepest integration barriers?

Planning, testing and quality assurance, and deployment and maintenance present the highest barriers. Planning lacks clean historical data for reliable estimation, testing faces the test oracle problem where generated assertions require costly human verification, and deployment and maintenance struggle with monolithic legacy systems that lack modern telemetry and observability interfaces.

How does code generation introduce hidden shadow technical debt?

Code generation introduces hidden technical debt when developers accept automated suggestions without thorough manual comprehension. Synthetic boilerplate often contains subtle logic bugs, unoptimized algorithms, hallucinated library calls, or deprecated dependencies that pass initial compilation but cause severe maintenance, scalability, and security issues during subsequent release cycles.

What strategies protect proprietary code when using AI development tools?

Organizations must establish zero-retention enterprise agreements with commercial model providers, deploy self-hosted open-weights models within private virtual clouds, implement automated static analysis gates to block confidential data leaks, and continuously scan generated code for open-source license violations before merge approval.

How can organizations measure whether AI integration is genuinely successful?

Organizations should measure success through system resilience, defect escape rates, developer cognitive flow, and cycle time from specification to verified production deployment, rather than superficial vanity metrics like total lines of code generated or raw pull request volume.

Related Research & Articles

To broaden your understanding of artificial intelligence across the software engineering landscape, explore our companion research reviews and architectural analyses: