From Code-Centric to Intent-Centric Software Engineering: A Reflexive Thematic Analysis of Generative AI, Agentic Systems, and Engineering Accountability

Abstract: Generative artificial intelligence (GenAI) and agentic systems are moving software engineering from code-centric production toward intent-centric human-agent work in which natural language, repository context, tools, tests, and governance shape delivery. Prior studies examine code generation, AI pair programming, and software engineering agents, but less is known about how public technical discourse and peer-reviewed evidence together frame the profession's near-term transition. This study addresses that gap through a reflexive thematic analysis (RTA) dominant and interpretative phenomenological analysis (IPA) informed public-discourse and document analysis. The corpus combines peer-reviewed software engineering and AI literature, technical benchmarks, public talks and interviews, essays, product-facing technical announcements, and X-originated discourse from prominent AI and software engineering voices. Sources were organized through a corpus register, codebook, coding matrix, theme-to-source traceability table, DOI/reference audit, and reproducibility protocol. The analysis shows that GenAI lowers the cost of producing plausible code while increasing the importance of intent specification, context curation, architecture knowledge, verification, security, provenance, governance, and accountable human judgment. The findings indicate that software engineering is becoming less about isolated code authorship and more about supervising, validating, and governing socio-technical systems of humans, agents, tools, and evidence gates. This matters because speed-focused adoption can accumulate hidden technical debt and accountability gaps, whereas bounded autonomy can preserve quality, security, maintainability, and trust.

• The paper demonstrates how generative AI reshapes software engineering by pivoting from code production to the specification of stakeholder intent.
• It employs reflexive thematic analysis and interpretative phenomenological analysis to integrate insights from academic, technical, and public discourses.
• The study proposes a five-stage maturity model that highlights governance challenges and accountability measures in agentic software engineering.

Intent-Centric Software Engineering: Reflexive Thematic Analysis of Generative AI and Agentic Systems

Introduction

The paper "From Code-Centric to Intent-Centric Software Engineering: A Reflexive Thematic Analysis of Generative AI, Agentic Systems, and Engineering Accountability" (2605.11027) analyzes the ongoing paradigm shift in software engineering precipitated by generative AI (GenAI) and agentic systems. Through a rigorously curated corpus of peer-reviewed literature, technical preprints, and diverse public discourse, the study employs reflexive thematic analysis (RTA) with interpretative phenomenological analysis (IPA) to articulate the transformation of software engineering from manual code production toward a framework driven by intent, context curation, architectural stewardship, and socio-technical governance.

Methodological Foundation

The study adopts an epistemologically interpretivist and constructivist approach. RTA is the dominant analytic method, permitting recursive theme development from heterogeneous artifacts—peer-reviewed publications, product releases, conference talks, and X posts. IPA informs individual researcher case profiles to retain idiographic perspectives prior to cross-case abstraction. The corpus is stratified into three evidentiary layers: scholarly publications, technical preprints, and public thought leadership, with stringent protocol for citation fidelity, reproducibility, and auditable claim traceability.

The Paradigm Shift: From Code-Centric to Intent-Centric

GenAI fundamentally lowers the marginal cost of plausible code by automating boilerplate generation, documentation drafting, and scaffolding, thus reframing the labor of software engineering. The essential complexity remains: specification of stakeholder intent, architectural tradeoff resolution, system-level verification, and long-term maintainability. GenAI neither obviates engineering judgment nor eliminates architectural rationale, but shifts the locus of expertise from implementation toward supervision and verification within human-agent systems.

The software artifact is increasingly hybrid, encompassing deterministic code, probabilistic model weights, prompts, retrieval pipelines, evaluation harnesses, and policy constraints. The development environment becomes a socio-technical system, intertwining human intent, agentic outputs, repository context, and organizational policy. Software engineers transition from isolated code authorship to supervisors of bounded-autonomous systems.

Dichotomies Structuring the Transition

The central tension articulated is acceleration versus accountability:

• Augmentation vs. Automation: AI tools augment code drafting and refactoring, yet humans retain responsibility for specifying intent, verifying outputs, and managing risks.
• Speed vs. Quality: Throughput increases, but artifact validation, architecture review, security assessment, and maintainability gain renewed importance.
• Prompting vs. Architecture: Natural language interfaces become the primary programming surface; yet, architecture knowledge must inform agent context and constrain code generation.
• Local Change vs. System Evolution: Agents solve discrete repository issues, while persistent system evolution demands explicit governance and architectural stewardship.
• Democratization vs. Professionalization: Lower barriers enable routine software creation by non-experts, but production-grade systems require advanced review, compliance, and accountability.
• Autonomy vs. Governance: Bounded automation requires policy-enforced workflows, auditability, identity management, permission controls, and evidence gates.

Interpretive Themes

The analysis yields eight interpretive themes, triangulated with the literature:

1. Natural Language as Programming Interface: The locus of programming shifts from syntactic code to intent and constraints expressed in natural language, emphasizing requirements clarity as the new engineering bottleneck.
2. Agentic Workflow Supersedes Single Prompting: The unit of work transitions to iterative agentic loops—planning, file edits, command execution, test repair, and pull requests—validating agent-generated artifacts within repository conventions.
3. Human Role as Architect, Verifier, Operator: Engineering value migrates from code production to architectural reasoning, artifact validation, and accountable integration into delivery pipelines.
4. Democratization with Professionalization: Widespread GenAI-enabled prototyping coexists with an increased professional standard for production software, raising the stakes for review and governance.
5. Contested Reasoning, Planning, and Autonomy: Agentic capabilities remain emergent—autonomy is bounded; mature practice differentiates task classes, requiring human supervision for complex or ambiguous domains.
6. Safety, Governance, and Provenance Debt: Access control, audit logging, sandboxing, policy enforcement, and provenance tracking become essential to manage the risks of agentic workflows.
7. Convergence of Software with AI Systems Engineering: Agentic engineering integrates code, models, orchestration, CI/CD, security scanning, and telemetry, demanding organizational practices for model evaluation, infrastructure, and incident response.
8. Persistent Essential Complexity and Technical Debt: Automation of accidental complexity does not erode essential complexity—design rationale, abstraction, evolution, and maintainability remain human-dependent and susceptible to technical debt.

Maturity Pathway for Agentic Software Engineering

A five-stage maturity model is constructed, delineating progression from individual agent-assisted coding, through team-governed workflows, to integrated lifecycle agents, and ultimately intent-centric engineering platforms and bounded-autonomous workflows:

• Stage 1: Agent-assisted drafting in IDEs and terminals.
• Stage 2: Team-level norms, permissions, review gates, and policy integration for agent workflows.
• Stage 3: Specialized agents for test, security, compliance integrated in delivery pipelines.
• Stage 4: Machine-readable requirements/architecture linked directly to agent workflows, with continuous acceptance evidence.
• Stage 5: Humans focus on architecture, risk, socio-technical coordination; routine change classes handled by supervised autonomy.

Risks are mapped at each stage: over-trust in agents, brittle orchestration, provenance gaps, ambiguous accountability, deskilling, misalignment of intent, and accumulation of governance debt.

Practical and Theoretical Implications

For Practitioner Leadership

Metrics should transcend lines of AI-generated code and focus on systemic quality: defect escape rates, review diligence, security findings, maintainability, and stakeholder value. Governance standards must delineate acceptable agent autonomy, review policies, and escalation procedures.

For Architects

Architecture knowledge should be operationalized—decision records, dependency maps, contracts, threat models, and requirements rendered computable for agentic integration.

For Security/Compliance

AI-generated artifacts require layered controls: static analysis, SBOM generation, prompt adversarial testing, and audit logging. Agent actions must be sandboxed with granular identity and policy enforcement.

For Education and Research

Educational curricula must adapt—students must learn to critique AI outputs, reason about engineering fundamentals, and understand socio-technical accountability. Future research should address longitudinal impacts of agentic code on technical debt, defect detection, repository safety, developer learning, and governance models.

Conclusion

The transition to intent-centric software engineering is marked by a shift in professional identity, responsibility boundaries, and system control. GenAI reduces the friction of code creation but increases the salience of architectural stewardship, evidence-based verification, security, provenance, and disciplined governance. The core dichotomy is not human versus AI, but acceleration versus accountability—strategic adoption lies in designing bounded-autonomous workflows that preserve system quality and public trust. This paradigm produces substantive theoretical and practical challenges, demanding ongoing research into organizational adaptation, agent governance, continuous evaluation, and human-agent collaboration (2605.11027).