AI-Assisted Software Development

Ask about this topic

Overview

AI-assisted software development studies how language models and coding agents can support work from requirements and design through implementation, testing, review, and maintenance. Common approaches include IDE code completion and chat, repository-aware retrieval, multi-step agents, and specification-driven workflows that use plans, tests, and architectural constraints to guide changes. Evaluation spans coding benchmarks and repository-level issue fixing, as well as real IDE traces, pull requests, static analysis, security checks, and fuzz testing. A central tension is that AI can speed up routine work while creating new costs in verification, security, maintainability, and developer understanding, so reliable use depends on effective feedback and human oversight.

Latest papers

CardsList

109 papers6 papers in the last four weeks, down 50% on the four weeks before. 0.0% of all new papers.

Apr 9, 2026

CIAO - Code In Architecture Out - Automated Software Architecture Documentation with Large Language Models

Software architecture documentation is essential for system comprehension, yet it is often unavailable or incomplete. While recent LLM-based techniques can generate documentation from code, they typically address local artifacts rather than producing coherent, system-level architectural descriptions. This paper presents a structured process for automatically generating system-level architectural documentation directly from GitHub repositories using Large Language Models. The process, called CIAO (Code In Architecture Out), defines an LLM-based workflow that takes a repository as input and produces system-level architectural documentation following a template derived from ISO/IEC/IEEE 42010, SEI Views & Beyond, and the C4 model. The resulting documentation can be directly added to the target repository. We evaluated the process through a study with 22 developers, each reviewing the documentation generated for a repository they had contributed to. The evaluation shows that developers generally perceive the produced documentation as valuable, comprehensible, and broadly accurate with respect to the source code, while also highlighting limitations in diagram quality, high-level context modeling, and deployment views. We also assessed the operational cost of the process, finding that generating a complete architectural document requires only a few minutes and is inexpensive to run. Overall, the results indicate that a structured, standards-oriented approach can effectively guide LLMs in producing system-level architectural documentation that is both usable and cost-effective.

Marco De Luca, Tiziano Santilli, Domenico Amalfitano +2

University of Naples Federico II Naples, Italy · University of Southern Denmark Odense, Denmark · Gran Sasso Science Institute L’Aquila, Italy

Automated Software EngineeringAI-Assisted Software Development
AskPDF
Apr 8, 2026

Evaluating Repository-level Software Documentation via Question Answering and Feature-Driven Development

Software documentation is crucial for repository comprehension. While Large Language Models (LLMs) advance documentation generation from code snippets to entire repositories, existing benchmarks have two key limitations: (1) they lack a holistic, repository-level assessment, and (2) they rely on unreliable evaluation strategies, such as LLM-as-a-judge, which suffers from vague criteria and limited repository-level knowledge. To address these issues, we introduce SWD-Bench, a novel benchmark for evaluating repository-level software documentation. Inspired by documentation-driven development, our strategy evaluates documentation quality by assessing an LLM's ability to understand and implement functionalities using the documentation, rather than by directly scoring it. This is measured through function-driven Question Answering (QA) tasks. SWD-Bench comprises three interconnected QA tasks: (1) Functionality Detection, to determine if a functionality is described; (2) Functionality Localization, to evaluate the accuracy of locating related files; and (3) Functionality Completion, to measure the comprehensiveness of implementation details. We construct the benchmark, containing 4,170 entries, by mining high-quality Pull Requests and enriching them with repository-level context. Experiments reveal limitations in current documentation generation methods and show that source code provides complementary value. Notably, documentation from the best-performing method improves the issue-solving rate of SWE-Agent by 20.00%, which demonstrates the practical value of high-quality documentation in supporting documentation-driven development.

Xinchen Wang, Ruida Hu, Cuiyun Gao +2

Harbin Institute of Technology, Shenzhen, China · Independent Researcher, China

Software Engineering BenchmarksAI-Assisted Software Development
AskPDF
Apr 6, 2026

Nidus: Externalized Reasoning for AI-Assisted Engineering

We present Nidus, a governance runtime that mechanizes the V-model for AI-assisted software delivery. In the self-hosting deployment, three LLM families (Claude, Gemini, Codex) delivered a 100,000-line system under proof obligations verified against the current obligation set on every commit. The system governed its own construction. Engineering invariants - traced requirements, justified architecture, evidenced deliveries - cannot be reliably maintained as learned behavior; assurance requires enforcement by a mechanism external to the proposer. Nidus externalizes the engineering methodology into a decidable artifact verified on every mutation before persistence. Organizational standards compile into guidebooks - constraint libraries imported by governed projects and enforced by decidable evaluation. Four contributions: (1) recursive self-governance - the constraint surface constrains mutations to itself; (2) stigmergic coordination - friction from the surface routes agents without central control; (3) proximal spec reinforcement - the living artifact externalizes the engineering context that RL and long-chain reasoning try to internalize; the specification is the reward function, UNSAT verdicts shape behavior at inference time, no weight updates; (4) governance theater prevention - compliance evidence cannot be fabricated within the modeled mutation path. The constraint surface compounds: each obligation permanently eliminates a class of unengineered output. The artifact's development history is a formal development - every state satisfies all active obligations, and the obligation set grows monotonically.

Danil Gorinevski

cybiont GmbH, Schübelbach, Switzerland · cybiont GmbH, Kantonsstrasse 17, 8862 Schübelbach, Switzerland

AI Agent GovernanceRuntime Enforcement for AI AgentsAI-Assisted Software DevelopmentRuntime VerificationSoftware Engineering Agents
AskPDF
Apr 4, 2026

AgenticFlict: A Large-Scale Dataset of Merge Conflicts in AI Coding Agent Pull Requests on GitHub

Software Engineering 3.0 marks a paradigm shift in software development, in which AI coding agents are no longer just assistive tools but active contributors. While prior empirical studies have examined productivity gains and acceptance patterns in AI-assisted development, the challenges associated with integrating agent-generated contributions remain less understood. In particular, merge conflicts, a fundamental aspect of collaborative software development, remain underexplored in this context. In this paper, we present AgenticFlict, a large-scale dataset of textual merge conflicts in AI coding agent pull requests (Agentic PRs). The dataset comprises 142K+ Agentic PRs collected from 59K+ repositories, of which 107K+ are successfully processed through deterministic merge simulation. Our pipeline identifies 29K+ PRs exhibiting merge conflicts, yielding a conflict rate of 27.67%, and extracts 336K+ fine-grained conflict regions across these instances. Our preliminary exploratory analysis indicates that merge conflicts are both frequent and often substantial in AI-generated contributions, with noticeable variation across agents, emphasizing the need to better understand and manage integration challenges in AI-assisted software development. The dataset, code and supplementary materials are available in zenodo: https://doi.org/10.5281/zenodo.19396916.

Daniel Ogenrwot, John Businge

University of Nevada Las Vegas Las Vegas, USA

AI Coding AgentsAI-Assisted Software Development
AskPDF
Apr 3, 2026

AI-Assisted Unit Test Writing and Test-Driven Code Refactoring: A Case Study

Many software systems originate as prototypes or minimum viable products (MVPs), developed with an emphasis on delivery speed and responsiveness to changing requirements rather than long-term code maintainability. While effective for rapid delivery, this approach can result in codebases that are difficult to modify, presenting a significant opportunity cost in the era of AI-assisted or even AI-led programming. In this paper, we present a case study of using coding models for automated unit test generation and subsequent safe refactoring, with proposed code changes validated by passing tests. The study examines best practices for iteratively generating tests to capture existing system behavior, followed by model-assisted refactoring under developer supervision. We describe how this workflow constrained refactoring changes, the errors and limitations observed in both phases, the efficiency gains achieved, when manual intervention was necessary, and how we addressed the weak value misalignment we observed in models. Using this approach, we generated nearly 16,000 lines of reliable unit tests in hours rather than weeks, achieved up to 78% branch coverage in critical modules, and significantly reduced regression risk during large-scale refactoring. These results illustrate software engineering's shift toward an empirical science, emphasizing data collection and constraining mechanisms that support fast, safe iteration.

Ema Smolic, Mario Brcic, Luka Hobor +1

It from Bit d.o.o., Zagreb, Croatia · Faculty of Electrical Engineering and Computing, University of Zagreb, Croatia

Automated Code RefactoringAI-Assisted Software DevelopmentAutomated Software EngineeringAutomated Test Generation
AskPDF
Apr 1, 2026

Investigating Autonomous Agent Contributions in the Wild: Activity Patterns and Code Change over Time

The rise of large language models for code has reshaped software development. Autonomous coding agents, able to create branches, open pull requests, and perform code reviews, now actively contribute to real-world projects. Their growing role offers a unique and timely opportunity to investigate AI-driven contributions and their effects on code quality, team dynamics, and software maintainability. In this work, we construct a novel dataset of approximately 110,000110,000 open-source pull requests, including associated commits, comments, reviews, issues, and file changes, collectively representing millions of lines of source code. We compare five popular coding agents, including OpenAI Codex, Claude Code, GitHub Copilot, Google Jules, and Devin, examining how their usage differs in various development aspects such as merge frequency, edited file types, and developer interaction signals, including comments and reviews. Furthermore, we emphasize that code authoring and review are only a small part of the larger software engineering process, as the resulting code must also be maintained and updated over time. Hence, we offer several longitudinal estimates of survival and churn rates for agent-generated versus human-authored code. Ultimately, our findings indicate an increasing agent activity in open-source projects, although their contributions are associated with more churn over time compared to human-authored code.

Razvan Mihai Popescu, David Gros, Andrei Botocan +3

Delft University of Technology, Delft, The Netherlands · University of California, Davis, Davis, USA · GitHub, Denver, USA

Mining Software RepositoriesCoding AgentsAI-Assisted Software DevelopmentSoftware Engineering
AskPDF
Mar 31, 2026

Unified Architecture Metamodel of Information Systems Developed by Generative AI

The rapid development of AI and LLMs has driven new methods of SDLC, in which a large portion of code, technical, and business documentation is generated automatically. However, since there is no single architectural framework that can provide consistent, repeatable transformations across different representation layers of information systems, such systems remain fragmented in their system representation. This study explores the problem of creating a unified architecture for LLM-oriented applications based on selected architectural frameworks by SMEs. A framework structure is proposed that covers some key types of architectural diagrams and supports a closed cycle of transformations, such as: "Code to Documentation to Code". The key architectural diagrams are split equally between main architectural layers: high-layer (business and domain understanding), middle-layer (system architecture), and low-layer (developer-layer architecture). Each architectural layer still contains some abstraction layers, which make it more flexible and better fit the requirements of design principles and architectural patterns. The conducted experiments demonstrated the stable quality of generated documentation and code when using a structured architectural context in the form of architectural diagrams. The results confirm that the proposed unified architecture metamodel can serve as an effective interface between humans and models, improving the accuracy, stability, and repeatability of LLM generation. However, the selected set of architectural diagrams should be optimised to avoid redundancy between some diagrams, and some diagrams should be updated to represent extra contextual orchestration. This work demonstrates measurable improvements for a new generation of intelligent tools that automate the SDLC and enable a comprehensive architecture compatible with AI-driven development.

Oleg Grynets, Vasyl Lyashkevych

EPAM Systems, McLean, Virginia, USA · EPAM Systems, Lviv, Ukraine

Model-Driven EngineeringSoftware EngineeringSoftware Architecture DesignAI-Assisted Software DevelopmentLLM Code Generation
AskPDF
Mar 31, 2026

IACDM: Interactive Adversarial Convergence Development Methodology -- A Structured Framework for AI-Assisted Software Development

Adoption of AI-assisted development in 2025 exposed a tool-agnostic failure pattern: experienced developers using frontier models were measurably slower while believing they were faster, and 10.3% of applications in one production showcase leaked data through misconfigured access. These failures share a structural cause, the verification gap: absent external tool use, no language model can determine whether what it generated is correct. The tool is irrelevant; the process is determinative. We present IACDM (Interactive Adversarial Convergence Development Methodology), an 8-phase framework in which verification agents external to the generator operate at discrete gates, and the AI alternates between building artifacts and attacking them through specialized critique lenses. What distinguishes it from the review and red-teaming traditions it borrows from is that the gate is enforced by a state machine outside the model: the agent may request advancement, not grant it. One component has now been tested. A pre-registered experiment over twelve projects under a single frozen instrument asked whether the nineteen lenses are non-redundant, against a prior expectation from replications of Perspective-Based Reading, which found reading perspectives not to differ. Every lens found at least one defect no other lens found, under four independent judgements of what counts as the same defect. Two further results were unplanned: the taxonomy withstands testing while the criterion deciding when to apply it does not, and the method creates commitments nothing ever re-confronts with the built system. The method was otherwise developed at one industrial R&D institute. That evidence establishes applicability, not effectiveness: no project ran without the method, and the proponents are the evaluators. Whether IACDM outperforms direct prompting remains open, and this paper is written to make it refutable.

Jasmine Moreira

AI-Assisted Software DevelopmentAI Coding AgentsAutomated Code Review
AskPDF
Mar 26, 2026

Factors Influencing the Quality of AI-Generated Code: A Synthesis of Empirical Evidence

Context: The rapid adoption of AI-assisted code generation tools, such as large language models (LLMs), is transforming software development practices. While these tools promise significant productivity gains, concerns regarding the quality, reliability, and security of AI-generated code are increasingly reported in both academia and industry. --Objective: This study aims to systematically synthesize existing empirical evidence on the factors influencing the quality of AI-generated source code and to analyze how these factors impact software quality outcomes across different evaluation contexts. --Method: We conducted a systematic literature review (SLR) following established guidelines, supported by an AI-assisted workflow with human oversight. A total of 24 primary studies were selected through a structured search and screening process across major digital libraries. Data were extracted and analyzed using qualitative, pattern-based evidence synthesis. --Results: The findings reveal that code quality in AI-assisted development is influenced by a combination of human factors, AI system characteristics, and human AI interaction dynamics. Key influencing factors include prompt design, task specification, and developer expertise. The results also show variability in quality outcomes such as correctness, security, maintainability, and complexity across studies, with both improvements and risks reported. --Conclusion: AI-assisted code generation represents a socio-technical shift in software engineering, where achieving high-quality outcomes depends on both technological and human factors. While promising, AI-generated code requires careful validation and integration into development workflows.

Vehid Geruslu, Zulfiyya Aliyeva, Eray Tüzün

Queen’s University Belfast, Belfast, United Kingdom · Azerbaijan Technical University, Baku, Azerbaijan · MilliSoft MMC Corporation, Baku, Azerbaijan +1

AI-Assisted Software DevelopmentCode Generation EvaluationHuman-AI Interaction
AskPDF
Mar 17, 2026

The State of Generative AI in Software Development: Insights from Literature and a Developer Survey

Generative Artificial Intelligence (GenAI) rapidly transforms software engineering, yet existing research remains fragmented across individual tasks in the Software Development Lifecycle. This study integrates a systematic literature review with a survey of 65 software developers. The results show that GenAI exerts its highest impact in design, implementation, testing, and documentation, where over 70 % of developers report at least halving the time for boilerplate and documentation tasks. 79 % of survey respondents use GenAI daily, preferring browser-based Large Language Models over alternatives integrated directly in their development environment. Governance is maturing, with two-thirds of organizations maintaining formal or informal guidelines. In contrast, early SDLC phases such as planning and requirements analysis show markedly lower reported benefits. In a nutshell, GenAI shifts value creation from routine coding toward specification quality, architectural reasoning, and oversight, while risks such as uncritical adoption, skill erosion, and technical debt require robust governance and human-in-the-loop mechanisms.

Vincent Gurgul, Robin Gubela, Stefan Lessmann

Chair of Information Systems Humboldt-Universität zu Berlin Unter den Linden 6, 10117 Berlin · Chair of Information Systems Hochschule für Technik und Wirtschaft Berlin Treskowallee 8, 10318 Berlin · Bucharest University of Economic Studies 6 Piata Romana, 010374, Romania

Generative AI AdoptionAI-Assisted Software DevelopmentHuman-AI Collaboration
AskPDF
Mar 15, 2026

LLM-Augmented Release Intelligence: Automated Change Summarization and Impact Analysis in Cloud-Native CI/CD Pipelines

Cloud-native software delivery platforms orchestrate releases through complex, multi-stage pipelines composed of dozens of independently versioned tasks. When code is promoted between environments -- development to staging, staging to production -- engineering teams need timely, accurate communication about what changed and what downstream components are affected. Manual preparation of such release communication is slow, inconsistent, and particularly error-prone in repositories where a single promotion may bundle contributions from many authors across numerous pipeline tasks. We present a framework for AI-augmented release intelligence that combines three capabilities: (1) automated commit collection with semantic filtering to surface substantive changes while suppressing routine maintenance, (2) structured large language model summarization that produces categorized, stakeholder-oriented promotion reports, and (3) static task-pipeline dependency analysis that maps modified tasks to every pipeline they participate in, quantifying the blast radius of each change. The framework is integrated directly into the CI/CD promotion workflow and operates as a post-promotion step triggered by GitHub Actions. We describe the architecture and implementation within a production Kubernetes-native release platform that manages over sixty Tekton tasks across more than twenty release pipelines. Through concrete walkthrough examples and qualitative comparison with recent tools such as SmartNote and VerLog, we discuss the distinctive requirements of internal promotion communication versus user-facing release notes and identify open challenges for LLM-driven release engineering.

Happy Bhati

Northeastern University

Software EngineeringAutomated Software EngineeringAI-Assisted Software Development
AskPDF
Mar 15, 2026

"I'm Not Reading All of That": Understanding Software Engineers' Level of Cognitive Engagement with Agentic Coding Assistants

Over-reliance on AI systems can undermine users' critical thinking and promote complacency, a risk intensified by the emergence of agentic AI systems that operate with minimal human involvement. In software engineering, agentic coding assistants (ACAs) are rapidly becoming embedded in everyday development workflows. Since software engineers (SEs) create systems deployed across diverse and high-stakes real-world contexts, these assistants must function not merely as autonomous task performers but as Tools for Thought that actively support human reasoning and sensemaking. We conducted a formative study examining software engineers' cognitive engagement and sensemaking processes when working with an ACA. Our findings reveal that cognitive engagement consistently declines as tasks progress, and that current ACA designs provide limited affordances for reflection, verification, and meaning-making. Based on these findings, we identify concrete design opportunities leveraging richer interaction modalities and cognitive-forcing mechanisms to sustain engagement and promote deeper thinking in AI-assisted programming.

Carlos Rafael Catalan, Lheane Marie Dizon, Patricia Nicole Monderin +1

York University Toronto, Canada

AI Coding AgentsHuman-AI InteractionHuman-AI CollaborationAI-Assisted Software Development
AskPDF
Mar 11, 2026

Artificial Intelligence as a Catalyst for Innovation in Software Engineering

The rapid evolution and inherent complexity of modern software requirements demand highly flexible and responsive development methodologies. While Agile frameworks have become the industry standard for prioritizing iteration, collaboration, and adaptability, software development teams continue to face persistent challenges in managing constantly evolving requirements and maintaining product quality under tight deadlines. This article explores the intersection of Artificial Intelligence (AI) and Software Engineering (SE), to analyze how AI serves as a powerful catalyst for enhancing agility and fostering innovation. The research combines a comprehensive review of existing literature with an empirical study, utilizing a survey directed at Software Engineering professionals to assess the perception, adoption, and impact of AI-driven tools. Key findings reveal that the integration of AI (specifically through Machine Learning (ML) and Natural Language Processing (NLP) )facilitates the automation of tedious tasks, from requirement management to code generation and testing . This paper demonstrates that AI not only optimizes current Agile practices but also introduces new capabilities essential for sustaining quality, speed, and innovation in the future landscape of software development.

Carlos Alberto Fernández-y-Fernández, Jorge R. Aguilar-Cisneros

Universidad Tecnológica de la Mixteca Oaxaca, México · Secretaría de Ciencia, Humanidades, Tecnología e Innovación (SECIHTI-Puebla) & UPAEP University, Puebla, Pue., México

AI-Assisted Software DevelopmentSoftware EngineeringAutomated Software Engineering
AskPDF
Mar 10, 2026

Quality-Driven Agentic Reasoning for LLM-Assisted Software Design: Questions-of-Thoughts (QoT) as a Time-Series Self-QA Chain

Recent advances in large language models (LLMs) have accelerated AI-assisted software development, yet practical deployment remains constrained by incomplete implementations, weak modularization, and inconsistent security practices. We introduce Questions-of-Thoughts (QoT), a quality-driven inference-time scaffold that turns a user goal into (i) an ordered sequence of engineering steps and (ii) stepwise self-questioning to verify constraints and reduce omission errors, while maintaining a lightweight reasoning record that stabilizes subsequent design decisions. We evaluate QoT across three representative backend engineering domains: API Design, Data Communication, and File Systems. Each task requires multi-module decomposition and exposes standard failure modes in LLM-generated systems. To enable data-driven comparison, we score generated artifacts using an ISO/IEC-inspired quality rubric that measures Scalability, Completeness, Modularity, and Security. We report domain-wise gains as the change in total quality score, defined as the QoT score minus the NoQoT score. Results show capacity-dependent improvements: QoT yields consistent quality improvements for larger models and more complex domains, while smaller models may exhibit trade-offs under tight context and planning budgets. We release an open artifact with prompts, scoring guidelines, raw generations, and scripts that reproduce the reported tables and figures to support applied AI and data analytics research.

Yen-Ku Liu, Yun-Cheng Tsai

Department of Technology Application and Human Resource Development, National Taiwan Normal University, Taipei, Taiwan

AI-Assisted Software DevelopmentSoftware EngineeringLanguage Model Self-AssessmentMetacognition in Language Models
AskPDF
Mar 9, 2026

Eyla: Toward an Identity-Anchored LLM Architecture with Integrated Biological Priors -- Vision, Implementation Attempt, and Lessons from AI-Assisted Development

We present the design rationale, implementation attempt, and failure analysis of Eyla, a proposed identity-anchored LLM architecture that integrates biologically-inspired subsystems -- including HiPPO-initialized state-space models, zero-initialized adapters, episodic memory retrieval, and calibrated uncertainty training -- into a unified agent operating system running on consumer hardware. Unlike existing approaches that optimize models for generic helpfulness, Eyla targets identity consistency: the ability to maintain a coherent self-model under adversarial pressure, admit uncertainty, and resist manipulation. We propose the Identity Consistency Score (ICS), a novel benchmark for evaluating this property across LLMs. We then present an honest account of attempting to implement this architecture using AI coding assistants (Claude Code, Cursor) as a non-programmer, documenting a $1,000+ failure that produced a 1.27B parameter model with 86 brain subsystems contributing less than 2% to output. Our analysis identifies five systematic failure modes of AI-assisted development for novel architectures and offers concrete recommendations. To our knowledge, this is the first paper to combine an architectural vision with a documented first-person failure analysis of AI-assisted LLM development, providing lessons for both the AI systems and AI-assisted software engineering communities.

Arif Aditto

Independent Researcher, Dhaka, Bangladesh

Language ModelingAI-Assisted Software DevelopmentMemory-Augmented Language Model Agents
AskPDF
Mar 3, 2026

Human-Certified Module Repositories for the AI Age

Human-Certified Module Repositories (HCMRs) are introduced in this work as a new architectural model for constructing trustworthy software in the era of AI-assisted development. As large language models increasingly participate in code generation, configuration synthesis, and multi-component integration, the reliability of AI-assembled systems will depend critically on the trustworthiness of the building blocks they use. Today's software supply-chain incidents and modular development ecosystems highlight the risks of relying on components with unclear provenance, insufficient review, or unpredictable composition behavior. We argue that future AI-driven development workflows require repositories of reusable modules that are curated, security-reviewed, provenance-rich, and equipped with explicit interface contracts. To this end, we propose HCMRs, a framework that blends human oversight with automated analysis to certify modules and support safe, predictable assembly by both humans and AI agents. We present a reference architecture for HCMRs, outline a certification and provenance workflow, analyze threat surfaces relevant to modular ecosystems, and extract lessons from recent failures. We further discuss implications for governance, scalability, and AI accountability, positioning HCMRs as a foundational substrate for reliable and auditable AI-constructed software systems.

Szilárd Enyedi

Automation Department, Technical University of Cluj-Napoca, Romania

Software EngineeringSoftware Supply Chain SecurityAI-Assisted Software DevelopmentHuman Oversight of AI
AskPDF
Feb 23, 2026

Carbon-Aware Governance Gates: An Architecture for Sustainable GenAI Development

The rapid adoption of Generative AI (GenAI) in the software development life cycle (SDLC) increases computational demand, which can raise the carbon footprint of development activities. At the same time, organizations are increasingly embedding governance mechanisms into GenAI-assisted development to support trust, transparency, and accountability. However, these governance mechanisms introduce additional computational workloads, including repeated inference, regeneration cycles, and expanded validation pipelines, increasing energy use and the carbon footprint of GenAI-assisted development. This paper proposes Carbon-Aware Governance Gates (CAGG), an architectural extension that embeds carbon budgets, energy provenance, and sustainability-aware validation orchestration into human-AI governance layers. CAGG comprises three components: (i) an Energy and Carbon Provenance Ledger, (ii) a Carbon Budget Manager, and (iii) a Green Validation Orchestrator, operationalized through governance policies and reusable design patterns.

Mateen A. Abbasi, Tommi J. Mikkonen, Petri J. Ihantola +3

University of Jyväskylä, Jyväskylä, Finland · Tampere University, Tampere, Finland

Carbon-Aware ComputingAI GovernanceAI-Assisted Software DevelopmentEnergy-Efficient ML
AskPDF
Feb 23, 2026

When AI Teammates Meet Code Review: Collaboration Signals Shaping the Integration of Agent-Authored Pull Requests

Autonomous coding agents increasingly contribute to software development by submitting pull requests on GitHub; yet, little is known about how these contributions integrate into human-driven review workflows. We present a large empirical study of agent-authored pull requests using the public AIDev dataset, examining integration outcomes, resolution speed, and review-time collaboration signals. Using logistic regression with repository-clustered standard errors, we find that reviewer engagement has the strongest correlation with successful integration, whereas larger change sizes and coordination-disrupting actions, such as force pushes, are associated with a lower likelihood of merging. In contrast, iteration intensity alone provides limited explanatory power once collaboration signals are considered. A qualitative analysis further shows that successful integration occurs when agents engage in actionable review loops that converge toward reviewer expectations. Overall, our results highlight that the effective integration of agent-authored pull requests depends not only on code quality but also on alignment with established review and coordination practices.

Costain Nachuma, Minhaz Zibran

Idaho State University, USA

AI Coding AgentsAI-Assisted Software DevelopmentHuman-AI Collaboration
AskPDF
Feb 3, 2026

Declarative by Design, Assistable Only by Convention: Benchmarking Multi-Agent Frameworks for AI-Assistability

Multi-agent frameworks (MAFs) promise to simplify LLM-driven software development, yet no principled metric captures how well AI coding assistants can generate correct, framework-specific code. We introduce AI-assistability (AI\mathcal{AI}), a composite metric that quantifies a framework's amenability to AI-assisted development by combining structural alignment (σˉ\barσ) with functional correctness (pass@1). To evaluate this metric in a controlled setting, we design DDL2PropBank, a novel benchmark task that maps relational database schemas to PropBank semantic rolesets, and implement identical agent logic across ten frameworks using the Agent-as-a-Tool pattern. Our results challenge the intuition that declarative framework design guarantees AI-assistability: Agno, with a single canonical pattern and convention-aligned API, achieves the highest AI\mathcal{AI} score (0.55), while DSPy -- the most declarative framework by design -- scores lowest (0.07), as its novel abstractions are insufficiently represented in AI training data. We find that convention alignment, not declarative design alone, is the primary driver of AI-assistability (r=0.576r = 0.576 between σˉ\barσ and pass@1). All artifacts -- DDL2PropBank, PropBank MCP server, and all implementations -- are available at https://github.com/ahmeshaf/ddl2propbank

Shafiuddin Rehan Ahmed, Sourabh Deshpande

Center for Advanced AI, Accenture · Mountain View, California, USA

AI Agent BenchmarksCode Generation EvaluationMulti-Agent CodingAI-Assisted Software Development
AskPDF