TLDR: EvoDev is a new iterative framework for end-to-end software development using LLM-based agents, inspired by Feature-Driven Development. It decomposes user requirements into features, models their dependencies in a ‘Feature Map,’ and propagates multi-level context (business, design, code) across iterative development cycles. Evaluated on Android development tasks, EvoDev significantly outperforms existing LLM-agent baselines, achieving higher build success rates and functional completeness, while demonstrating generalizability across different LLMs and task difficulties with acceptable overhead. The framework highlights the importance of dependency modeling, context propagation, and workflow-aware agent design for complex software projects.
In the rapidly evolving world of artificial intelligence, large language models (LLMs) are increasingly being explored for automating complex tasks, including end-to-end software development. While these AI agents show great promise in generating software from natural language requirements, existing methods often fall short when faced with the intricate, iterative nature of real-world projects. Many current approaches use a simple, linear development style, similar to the ‘waterfall’ model, which struggles with larger, more complex software.
To address these limitations, a new framework called EvoDev has been introduced. EvoDev is an iterative software development framework inspired by Feature-Driven Development (FDD), a well-established agile methodology. This new approach aims to make LLM-based agents more effective in handling the complexities of modern software projects, particularly in challenging areas like Android development.
Understanding EvoDev’s Approach
EvoDev tackles the problem by breaking down user requirements into smaller, manageable, and user-valued features. It then creates a ‘Feature Map,’ which is essentially a visual representation (a directed acyclic graph) that clearly shows how different features depend on each other. Each point on this map holds various levels of information—from the core business logic to design specifications and actual code. This information is then passed along the dependency chain, providing crucial context for subsequent development steps.
The framework operates in three main stages:
- Overall Design Construction: This initial stage involves a Business Analyst agent structuring informal user requirements into a clear document, followed by an Architect agent creating a coarse-grained overall design, including essential UI components and data entities. This acts as a blueprint, ensuring consistency throughout the project.
- Feature Map Generation: A Feature Extractor agent breaks down the requirements and overall design into a detailed list of features. A Feature Planner then organizes these features into cohesive ‘feature sets,’ considering their dependencies and priorities. This results in the Feature Map, which stores business, design, and implementation context for each feature set.
- Iterative Features Development: In this final stage, a Chief Programmer agent refines the design for the current feature set and creates a detailed development plan. A Programmer agent then takes this plan, along with implementation context, to write and debug the code. EvoDev includes a clever memory mechanism for the Programmer agent to keep the development context clean and efficient, preventing it from getting bogged down by fragmented code changes. This iterative process continues until all features are implemented and the application is ready.
Impressive Results in Android Development
EvoDev was rigorously tested on challenging Android development tasks using a specially constructed dataset called APPDev. The results were highly encouraging. EvoDev significantly outperformed existing LLM-agent baselines, including Claude Code, MetaGPT, and GPT-Engineer. For instance, it surpassed the best-performing baseline, Claude Code, by a substantial 56.8% in functional completeness. It also achieved a perfect 100% build success rate, indicating that the applications it developed were not only syntactically correct but also functionally reliable and provided a high-quality user experience.
The framework demonstrated strong generalizability, showing consistent improvements across different base LLMs (like GPT-4.1, Claude-3.5-Sonnet, and Claude-4-Sonnet) and tasks of varying difficulty. Notably, GPT-4.1 saw a remarkable 76.6% relative improvement in functional completeness when integrated with EvoDev, highlighting the framework’s ability to leverage the LLM’s instruction-following capabilities effectively.
Also Read:
- Decoding Code Agent Decisions: An Analysis of Success and Failure Paths
- AgentGit: A New Approach to Reliable and Scalable AI Agents
Efficiency and Future Insights
While iterative development might intuitively seem more costly, EvoDev proved to be cost-efficient for certain LLMs. It achieved comparable monetary and time costs to single-agent baselines while delivering higher functional completeness per unit of cost. This efficiency stems from its ability to provide relevant context for each iteration, reducing redundant work and debugging time.
The research also offers valuable insights for the future of LLM-driven software development. It emphasizes the importance of balancing an LLM’s raw coding ability with its capacity for global planning and following instructions. It also points out potential misalignments between an LLM’s inherent behaviors (like excessive self-correction) and the desired workflow guidance, suggesting a need for better integration strategies.
In conclusion, EvoDev represents a significant step forward in automating end-to-end software development with LLM-based agents. By adopting an iterative, feature-driven approach and intelligently managing context through a Feature Map, it enables the creation of more robust, functional, and user-friendly applications. This work paves the way for more sophisticated and practical AI-assisted software engineering in the future. You can read the full research paper here.
