1 Introduction↩︎

Software evolution accounts for a substantial portion of software engineering effort. Unlike single-function generation tasks, practical evolution requires translating repository-level feature intent into coordinated code edits across multiple files. Prior studies [1] indicate that around 60% of repository maintenance tasks involve feature evolution.

Large language models (LLMs) are increasingly used for software evolution, and existing approaches mainly provide four interaction paradigms. Autocompletion tools (e.g., GitHub Copilot inline suggestions) improve local editing efficiency. Chat-based workflows (e.g., Cursor, SWE-Agent [2]) support natural-language intent expression for evolution tasks. Annotation-based approaches (e.g., NL Outlines [3], Code Shaping [4]) strengthen local intent-code alignment. Design-oriented systems (e.g., Pail [5], EvoDev [6]) improve planning quality for development from scratch.

However, these paradigms still provide limited support for repository-level feature evolution in existing repositories. They typically do not provide developers with an explicit feature list, making task descriptions ambiguous and inconsistent with the its actual structure. They also do not maintain a feature-to-code mapping, which reduces localization accuracy during requirement analysis and context retrieval. This gap is especially costly in unfamiliar repositories: developers must infer features and manually map intended feature changes to concrete edit locations, which imposes substantial cognitive overhead [7]. For example, a commit adding friend links in NBlog¹ spans 5 packages, 5 files, and 28 functions.

To address these problems, we present FeatX, a feature-oriented software evolution tool that supports editing software by editing features. FeatX integrates automatic feature extraction with an Evolution Agent. It treats extracted features as first-class editable units and maintains explicit feature-to-code mappings throughout generation. Given an existing repository, FeatX first constructs a hierarchical epic-feature structure with associated code entities, and then invokes a three-stage Evolution Agent (contextual expansion, localization & planning, and concrete code modification) to translate feature edits into code patches. The workflow is exposed through four coordinated panels (Feature Panel, CodeMap Panel, Agent Panel, and Diff Panel).

We evaluate FeatX along two dimensions: cognitive load and function-level modification localization accuracy. Across a user study and quantitative experiments on real-world feature-editing tasks, FeatX shows that: (1) compared with vanilla ChatGPT, it significantly reduces NASA-TLX cognitive load (\(12.5 \to 7.4\), 41% reduction) and improves usability (\(73 \to 84\), 15% increase); and (2) it improves function-level modification localization accuracy, achieving an F1 score of 0.385 and outperforming the strongest baseline, Claude-opus-4.5 (0.270), by 42.6%. Meanwhile, it only incurs an LLM cost of $0.07, in contrast to $45.05 for direct Claude invocation.

2 Tool Design↩︎

1 presents the overall design of FeatX. It extracts a hierarchical feature structure from a repository (2.1), lets users edit target features in the Feature Panel, and feeds the edited feature with associated code context to a three-stage Evolution Agent that outputs diffs (2.2).

2.1 Feature Extraction↩︎

2.1.1 Problem Formulation↩︎

We adopt a hierarchical requirement model inspired by Agile/Scrum [8]: each Epic contains multiple Features, and each feature is represented by a user story and supporting code entities.

Given a repository \(R\), we construct a two-level hierarchy \(E_R=\{e_1,\dots,e_n\}\), where each epic \(e_i\) contains features \(F_i=\{f_1,\dots,f_m\}\) and each feature \(f_j\) is associated with a user story \(s_j\) and code entities \(C_j\) (classes, methods, or files).

2.1.2 Extraction Pipeline↩︎

In our previous work [9], we introduced a feature-oriented code repository summarization approach. Here, we adapt this approach for feature extraction to build the hierarchical feature list used in FeatX. For both file-level and function-level entities, we first construct a binary structural matrix from static dependencies (e.g., imports and calls), and a continuous semantic matrix in \([0,1]\) from LLM-based summaries and Sentence-BERT embeddings. We then fuse the two matrices with weighted integration to obtain a unified similarity matrix at each granularity.

Next, we perform two-stage hierarchical clustering using the Leiden algorithm. Within the whole repository, we cluster the fused file-level matrix and ask the LLM to generate one description for each cluster as an epic. Within each epic, we further cluster the corresponding fused function-level representations and ask the LLM to generate descriptions for the resulting clusters as features. The final epic-feature hierarchy is shown in the Feature Panel for user editing.

2.2 Evolution Agent↩︎

FeatX implements a three-stage Evolution Agent to transform feature-level edits into code-level modifications. Given a user-edited feature, the agent also receives the original feature description and its associated code context, then executes contextual expansion, localization & planning, and code modification in sequence [10].

2.2.1 Contextual Expansion↩︎

To provide sufficient implementation context, this stage expands the initial code entities linked to the edited feature from two complementary perspectives: Static Analysis and Exploratory Retrieval.

In the Static Analysis branch, FeatX starts from the seed entities identified in 2.1 and expands them along repository-level dependency relations [11], including method calls, field use references, field definitions, type use references, class membership, and inheritance/nesting hierarchies. In the Exploratory Retrieval branch, FeatX leverages LLM-guided exploration to introduce additional semantically relevant entities that may not be reachable through static dependency expansion.

The result is an enriched CodeMap for downstream reasoning, visualized in the CodeMap Panel.

2.2.2 Localization and Planning↩︎

This stage compares the feature description before and after user edits, and combines the semantic delta with the expanded code context. Based on this joint signal, the agent localizes the change intent to a small set of concrete code regions. It then generates a fine-grained modification plan for each localized region, including required edits, dependencies, and execution order. The reasoning process and planning results are displayed in the Agent Panel.

2.2.3 Concrete Code Modification↩︎

This stage modifies concrete code entities according to localized targets and plans. The output is produced as class-wise line-level diffs in the Diff Panel for review and confirmation. In addition, affected classes are highlighted in the CodeMap Panel.

This three-stage design makes feature editing operational in practice: user intent is first grounded into an enriched CodeMap, then translated into explicit edit plans, and finally materialized as reviewable diffs with affected entities highlighted in the interface.

3 Implementation and Usage↩︎

FeatX is implemented as a decoupled web system with a Java Spring Boot backend and a JavaScript React frontend. To support software evolution in Java repositories, we use JavaParser [12] for static analysis and dependency resolution. In feature extraction, we set the fusion weight between the structural and semantic matrices to \(\alpha=0.5\), and apply adaptive tuning to select the best \(\gamma\) for cluster partitioning modularity (CPM). Across the system, all LLM-dependent components, including feature extraction and Evolution Agent, use the same open-source DeepSeek-v3 configuration with temperature 0.0 to ensure deterministic behavior.

As shown in 2, FeatX provides a concise feature-oriented workflow through four coordinated panels: the Feature Panel lists extracted epics and features hierarchically and supports direct addition, modification, and removal operations; the CodeMap Panel visualizes feature-related code entities and highlights entities affected by the current edit; the Agent Panel presents the three-stage reasoning process of Evolution Agent; and the Diff Panel provides class-wise line-level code diffs for final review and confirmation. This feature-oriented workflow shifts user effort from manual repository navigation and context management to feature specification and targeted verification, improving traceability between feature intent and concrete code evolution.

4 Evaluation↩︎

To evaluate FeatX, we investigate the following research questions:

• From a user perspective, does FeatX reduce cognitive load and improve usability compared with vanilla ChatGPT?

• What function-level modification localization accuracy and cost does FeatX achieve?

The evaluation uses 38 feature-editing commits from five open-source Java repositories (FlappyBird, JSON-java, JCommander, NBlog, and PlayEdu) [9], with average complexity of 3.2 packages, 4.5 files, and 10.6 functions per task.

4.1 User-Perceived Interaction Quality↩︎

We recruited 10 participants (6 men and 4 women; ages 21–27), including 8 CS students (undergraduate to PhD) from 3 universities and 2 industry practitioners. Participants were recruited via snowball sampling and generally had prior Java/OOP experience and regular LLM usage experience. Each participant completed two medium-complexity feature-editing tasks selected from our commit dataset using both vanilla ChatGPT and FeatX. Each task involved modifications to 5–10 functions across multiple files, and each session was limited to one hour. We measured NASA-TLX [13] and SUS [14] with two-sided paired t-tests, and report only mean scores and significance levels due to page limits.

4.1.1 Cognitive Load Reduction↩︎

NASA-TLX rates workload on six dimensions using a 1–21 scale, where higher scores indicate higher cognitive load. As shown in 3, FeatX significantly reduces perceived cognitive load compared with ChatGPT, with the largest reductions in mental demand (6.6 vs.), effort (8.2 vs.), and frustration (7.7 vs.) (all \(p < 0.001\)). The only dimension without a significant difference is physical demand (\(p > 0.05\)). Averaged across all six dimensions, the mean NASA-TLX score decreases from 12.5 to 7.4 (41% reduction).

4.1.2 Usability Improvement↩︎

SUS consists of 10 items assessing overall system usability. 4 reports each participant’s final SUS score, showing a higher mean score for FeatX than ChatGPT (84 vs., 15% increase). At the item level, two-sided paired t-tests on the 10 SUS questions show that FeatX does not outperform ChatGPT on every item, but scores significantly higher on integration and consistency (\(p < 0.05\)), and especially on confidence (\(p < 0.001\)).

4.2 Function-Level Modification Localization Accuracy and Cost↩︎

We evaluate localization at the function level. For each task, we compare a ground-truth modified-function set \(G\) from commit history with a predicted set \(M\). We compute \(|M\cap G|\) as follows: function names are matched by exact match (EM), while newly created functions are manually assessed by the authors for correctness. We then compute \(\text{Precision}=\frac{|M\cap G|}{|M|}\), \(\text{Recall}=\frac{|M\cap G|}{|G|}\), and \(\text{F1}=\frac{2\cdot \text{Precision}\cdot \text{Recall}}{\text{Precision}+\text{Recall}}\).

We replayed 38 commits with FeatX, several SOTA LLMs, and Cursor (Agent mode, default model composer-1.5), and reported function-level localization metrics and cost in 1. The prompting protocol is accessible in our repository. FeatX achieved the highest F1 (0.385), with 41.6% precision and 35.8% recall, while the second-best F1 was achieved by Claude-opus-4.5 (0.270), corresponding to a 42.6% relative improvement. Despite being widely used in practice, Cursor Agent attains only 13.0% recall and has the lowest precision (15.9%). In addition, FeatX incurs lower LLM cost ($0.07 in total) than direct Claude invocation ($45.05).

5 Conclusion and Future Work↩︎

We present FeatX, a feature-oriented tool for LLM-assisted software evolution. FeatX enables editing software by editing features, with explicit feature extraction and a three-stage Evolution Agent. Our evaluation shows improvements in user-perceived interaction quality and function-level modification localization, together with strong cost efficiency. In future work, we will improve robustness in complex edits, support interactive relevant-code augmentation, and evaluating on larger repositories with more diverse participants.

References↩︎