What’s holding AI back from automating software development?

A new study sheds light on the current limitations and untapped potential of artificial intelligence in software engineering. As generative AI tools become increasingly common in development pipelines, this new research identifies major blind spots that still prevent full-scale automation of routine programming tasks.

Published on arXiv, the study “Challenges and Paths Towards AI for Software Engineering” categorizes a wide range of tasks where AI is currently used in software development, highlights core technical and organizational challenges, and proposes targeted research directions to accelerate future progress. The authors argue that while AI has demonstrated remarkable progress in specific coding tasks, the broader vision of autonomous software development remains far from realized.

Where is AI actually helping in software development?

The study maps out a structured taxonomy of AI-driven software engineering tasks that go far beyond popular use cases like code generation. It includes code transformation, software testing, maintenance, documentation, refactoring, and even formal verification. These tasks form the backbone of modern software lifecycles, yet AI integration in many of these domains remains limited.

For example, the paper highlights how AI can support testing and debugging, optimize outdated code, assist in pull request (PR) reviews, and navigate complex legacy codebases. However, many of these tools are narrowly scoped, unable to generalize well across programming languages, software frameworks, or development environments.

The authors also flag a recurring issue: while AI models can often generate syntactically correct code snippets, they frequently lack a semantic understanding of the overall software architecture. This gap prevents them from reliably making context-aware decisions that human developers routinely handle. Even in code generation, which has seen the most rapid commercial deployment, models often require significant human intervention and oversight.

What are the core bottlenecks in scaling AI for development?

Despite the growing popularity of large language models in software tools, the study identifies critical roadblocks that slow down adoption and limit reliability.

First, the researchers call out the lack of standardized, realistic benchmarks to evaluate the performance of AI tools in real-world environments. Most benchmarks are synthetic and fail to capture the complexities of actual software projects, making it difficult to measure meaningful progress.

The paper also stresses that AI tools are rarely optimized for effective collaboration with human developers. The friction between automated suggestions and human intent often leads to inefficiencies, as users either ignore or must rework AI outputs. Without meaningful human-AI interaction design, even powerful models fall short in everyday use.

Other challenges include:

• Long-horizon code planning: Current models struggle to reason across large, interconnected codebases that require consistent logic over dozens or hundreds of files.
• Semantic code understanding: AI lacks deep comprehension of application logic, design patterns, or domain-specific constraints.
• Tool fragmentation: AI-generated code frequently clashes with software engineering tools like linters, version control, and build pipelines, reducing integration reliability.

The study also points out that specialized domains (e.g., embedded systems, scientific computing, or outdated code libraries) suffer disproportionately due to a lack of labeled training data and architectural support.

What needs to change to realize fully automated software engineering?

To overcome these limitations, the authors propose a multifaceted roadmap centered on three pillars: data, training, and inference-time optimization.

• Data Curation: The paper advocates for large-scale, structured datasets created from real-world repositories, including both automated and human-validated code examples. This would help in capturing complex patterns across diverse languages, domains, and use cases.
• Human-Centric Model Training: The study recommends building training environments that mimic real coding workflows. By incorporating reinforcement learning and human feedback loops, future models could learn to collaborate more intuitively with developers rather than function as passive code generators.
• Semantic-Aware Inference: The authors emphasize the need for models to understand code intent, software design structures, and runtime behavior. This could be achieved by embedding AI systems more tightly within IDEs, version control systems, and project management tools, effectively making them active participants in the software lifecycle.

The paper further calls for better support for low-resource programming languages, mechanisms to handle library and API version updates, and dynamic adaptation to rapidly evolving codebases.